From a15da8e2755cfc2aa19b030f74bc71d69258cdfb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Salvatore=20Ravida=CC=80?= Date: Thu, 15 Dec 2022 11:19:46 +0100 Subject: [PATCH] Added pgSQL support --- build/antlr4.js | 1 + package.json | 2 +- src/grammar/pgsql/PostgreSQLLexer.g4 | 2544 + src/grammar/pgsql/PostgreSQLParser.g4 | 5327 + src/lib/pgsql/PostgreSQLLexer.interp | 1702 + src/lib/pgsql/PostgreSQLLexer.js | 4873 + src/lib/pgsql/PostgreSQLLexer.tokens | 1066 + src/lib/pgsql/PostgreSQLParser.interp | 1925 + src/lib/pgsql/PostgreSQLParser.js | 129402 +++++++++++++++ src/lib/pgsql/PostgreSQLParser.tokens | 1066 + src/lib/pgsql/PostgreSQLParserListener.js | 7305 + src/lib/pgsql/PostgreSQLParserVisitor.js | 4876 + .../base/LexerDispatchingErrorListener.java | 55 + .../base/ParserDispatchingErrorListener.java | 55 + src/lib/pgsql/base/PostgreSQLLexerBase.js | 67 + src/lib/pgsql/base/PostgreSQLParserBase.js | 114 + src/parser/common/basicParser.ts | 13 +- src/parser/pgsql.ts | 17 + tsconfig.json | 2 +- yarn.lock | 2750 +- 20 files changed, 161798 insertions(+), 1364 deletions(-) create mode 100644 src/grammar/pgsql/PostgreSQLLexer.g4 create mode 100644 src/grammar/pgsql/PostgreSQLParser.g4 create mode 100644 src/lib/pgsql/PostgreSQLLexer.interp create mode 100644 src/lib/pgsql/PostgreSQLLexer.js create mode 100644 src/lib/pgsql/PostgreSQLLexer.tokens create mode 100644 src/lib/pgsql/PostgreSQLParser.interp create mode 100644 src/lib/pgsql/PostgreSQLParser.js create mode 100644 src/lib/pgsql/PostgreSQLParser.tokens create mode 100644 src/lib/pgsql/PostgreSQLParserListener.js create mode 100644 src/lib/pgsql/PostgreSQLParserVisitor.js create mode 100644 src/lib/pgsql/base/LexerDispatchingErrorListener.java create mode 100644 src/lib/pgsql/base/ParserDispatchingErrorListener.java create mode 100644 src/lib/pgsql/base/PostgreSQLLexerBase.js create mode 100644 src/lib/pgsql/base/PostgreSQLParserBase.js create mode 100644 src/parser/pgsql.ts diff --git a/build/antlr4.js b/build/antlr4.js index 7bd8d03..870ca07 100644 --- a/build/antlr4.js +++ b/build/antlr4.js @@ -8,6 +8,7 @@ const output = path.resolve(__dirname, '../src/lib'); const entry = [ 'generic', 'hive', + 'pgsql', 'plsql', 'spark', 'flinksql', diff --git a/package.json b/package.json index f1d8df2..8e875e6 100644 --- a/package.json +++ b/package.json @@ -32,7 +32,7 @@ "eslint-config-google": "^0.14.0", "jest": "^24.8.0", "ts-jest": "^24.1.0", - "typescript": "^3.6.3", + "typescript": "^4.9.4", "standard-version": "^9.1.0" }, "git repository": "https://github.com/DTStack/dt-sql-parser", diff --git a/src/grammar/pgsql/PostgreSQLLexer.g4 b/src/grammar/pgsql/PostgreSQLLexer.g4 new file mode 100644 index 0000000..6646eda --- /dev/null +++ b/src/grammar/pgsql/PostgreSQLLexer.g4 @@ -0,0 +1,2544 @@ +/* +based on +https://github.com/tunnelvisionlabs/antlr4-grammar-postgresql/blob/master/src/com/tunnelvisionlabs/postgresql/PostgreSqlLexer.g4 +*/ + +/* + * [The "MIT license"] + * Copyright (C) 2014 Sam Harwell, Tunnel Vision Laboratories, LLC + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * 1. The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * 2. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * 3. Except as contained in this notice, the name of Tunnel Vision + * Laboratories, LLC. shall not be used in advertising or otherwise to + * promote the sale, use or other dealings in this Software without prior + * written authorization from Tunnel Vision Laboratories, LLC. + */ +lexer grammar PostgreSQLLexer; +/* Reference: + * http://www.postgresql.org/docs/9.3/static/sql-syntax-lexical.html + */ + +options { + superClass = PostgreSQLLexerBase; + caseInsensitive = true; +} + +@ header +{ +} +@ members +{ +/* This field stores the tags which are used to detect the end of a dollar-quoted string literal. + */ +} +// + +// SPECIAL CHARACTERS (4.1.4) + +// + +// Note that Asterisk is a valid operator, but does not have the type Operator due to its syntactic use in locations + +// that are not expressions. + +Dollar + : '$' + ; + +OPEN_PAREN + : '(' + ; + +CLOSE_PAREN + : ')' + ; + +OPEN_BRACKET + : '[' + ; + +CLOSE_BRACKET + : ']' + ; + +COMMA + : ',' + ; + +SEMI + : ';' + ; + +COLON + : ':' + ; + +STAR + : '*' + ; + +EQUAL + : '=' + ; + +DOT + : '.' + ; + //NamedArgument : ':='; + +PLUS + : '+' + ; + +MINUS + : '-' + ; + +SLASH + : '/' + ; + +CARET + : '^' + ; + +LT + : '<' + ; + +GT + : '>' + ; + +LESS_LESS + : '<<' + ; + +GREATER_GREATER + : '>>' + ; + +COLON_EQUALS + : ':=' + ; + +LESS_EQUALS + : '<=' + ; + +EQUALS_GREATER + : '=>' + ; + +GREATER_EQUALS + : '>=' + ; + +DOT_DOT + : '..' + ; + +NOT_EQUALS + : '<>' + ; + +TYPECAST + : '::' + ; + +PERCENT + : '%' + ; + +PARAM + : '$' ([0-9])+ + ; + // + + // OPERATORS (4.1.3) + + // + + // this rule does not allow + or - at the end of a multi-character operator + +Operator + : ((OperatorCharacter | ('+' | '-' + {checkLA('-')}?)+ (OperatorCharacter | '/' + {checkLA('*')}?) | '/' + {checkLA('*')}?)+ | // special handling for the single-character operators + and - + [+-]) + //TODO somehow rewrite this part without using Actions + + { + HandleLessLessGreaterGreater(); + } + ; +/* This rule handles operators which end with + or -, and sets the token type to Operator. It is comprised of four + * parts, in order: + * + * 1. A prefix, which does not contain a character from the required set which allows + or - to appear at the end of + * the operator. + * 2. A character from the required set which allows + or - to appear at the end of the operator. + * 3. An optional sub-token which takes the form of an operator which does not include a + or - at the end of the + * sub-token. + * 4. A suffix sequence of + and - characters. + */ + + +OperatorEndingWithPlusMinus + : (OperatorCharacterNotAllowPlusMinusAtEnd | '-' + {checkLA('-')}? | '/' + {checkLA('*')}?)* OperatorCharacterAllowPlusMinusAtEnd Operator? ('+' | '-' + {checkLA('-')}?)+ -> type (Operator) + ; + // Each of the following fragment rules omits the +, -, and / characters, which must always be handled in a special way + + // by the operator rules above. + +fragment OperatorCharacter + : [*<>=~!@%^&|`?#] + ; + // these are the operator characters that don't count towards one ending with + or - + +fragment OperatorCharacterNotAllowPlusMinusAtEnd + : [*<>=+] + ; + // an operator may end with + or - if it contains one of these characters + +fragment OperatorCharacterAllowPlusMinusAtEnd + : [~!@%^&|`?#] + ; + // + + // KEYWORDS (Appendix C) + + // + + // + + // reserved keywords + + // + +ALL + : 'ALL' + ; + +ANALYSE + : 'ANALYSE' + ; + +ANALYZE + : 'ANALYZE' + ; + +AND + : 'AND' + ; + +ANY + : 'ANY' + ; + +ARRAY + : 'ARRAY' + ; + +AS + : 'AS' + ; + +ASC + : 'ASC' + ; + +ASYMMETRIC + : 'ASYMMETRIC' + ; + +BOTH + : 'BOTH' + ; + +CASE + : 'CASE' + ; + +CAST + : 'CAST' + ; + +CHECK + : 'CHECK' + ; + +COLLATE + : 'COLLATE' + ; + +COLUMN + : 'COLUMN' + ; + +CONSTRAINT + : 'CONSTRAINT' + ; + +CREATE + : 'CREATE' + ; + +CURRENT_CATALOG + : 'CURRENT_CATALOG' + ; + +CURRENT_DATE + : 'CURRENT_DATE' + ; + +CURRENT_ROLE + : 'CURRENT_ROLE' + ; + +CURRENT_TIME + : 'CURRENT_TIME' + ; + +CURRENT_TIMESTAMP + : 'CURRENT_TIMESTAMP' + ; + +CURRENT_USER + : 'CURRENT_USER' + ; + +DEFAULT + : 'DEFAULT' + ; + +DEFERRABLE + : 'DEFERRABLE' + ; + +DESC + : 'DESC' + ; + +DISTINCT + : 'DISTINCT' + ; + +DO + : 'DO' + ; + +ELSE + : 'ELSE' + ; + +EXCEPT + : 'EXCEPT' + ; + +FALSE_P + : 'FALSE' + ; + +FETCH + : 'FETCH' + ; + +FOR + : 'FOR' + ; + +FOREIGN + : 'FOREIGN' + ; + +FROM + : 'FROM' + ; + +GRANT + : 'GRANT' + ; + +GROUP_P + : 'GROUP' + ; + +HAVING + : 'HAVING' + ; + +IN_P + : 'IN' + ; + +INITIALLY + : 'INITIALLY' + ; + +INTERSECT + : 'INTERSECT' + ; + +INTO + : 'INTO' + ; + +LATERAL_P + : 'LATERAL' + ; + +LEADING + : 'LEADING' + ; + +LIMIT + : 'LIMIT' + ; + +LOCALTIME + : 'LOCALTIME' + ; + +LOCALTIMESTAMP + : 'LOCALTIMESTAMP' + ; + +NOT + : 'NOT' + ; + +NULL_P + : 'NULL' + ; + +OFFSET + : 'OFFSET' + ; + +ON + : 'ON' + ; + +ONLY + : 'ONLY' + ; + +OR + : 'OR' + ; + +ORDER + : 'ORDER' + ; + +PLACING + : 'PLACING' + ; + +PRIMARY + : 'PRIMARY' + ; + +REFERENCES + : 'REFERENCES' + ; + +RETURNING + : 'RETURNING' + ; + +SELECT + : 'SELECT' + ; + +SESSION_USER + : 'SESSION_USER' + ; + +SOME + : 'SOME' + ; + +SYMMETRIC + : 'SYMMETRIC' + ; + +TABLE + : 'TABLE' + ; + +THEN + : 'THEN' + ; + +TO + : 'TO' + ; + +TRAILING + : 'TRAILING' + ; + +TRUE_P + : 'TRUE' + ; + +UNION + : 'UNION' + ; + +UNIQUE + : 'UNIQUE' + ; + +USER + : 'USER' + ; + +USING + : 'USING' + ; + +VARIADIC + : 'VARIADIC' + ; + +WHEN + : 'WHEN' + ; + +WHERE + : 'WHERE' + ; + +WINDOW + : 'WINDOW' + ; + +WITH + : 'WITH' + ; + + // + + // reserved keywords (can be function or type) + + // + +AUTHORIZATION + : 'AUTHORIZATION' + ; + +BINARY + : 'BINARY' + ; + +COLLATION + : 'COLLATION' + ; + +CONCURRENTLY + : 'CONCURRENTLY' + ; + +CROSS + : 'CROSS' + ; + +CURRENT_SCHEMA + : 'CURRENT_SCHEMA' + ; + +FREEZE + : 'FREEZE' + ; + +FULL + : 'FULL' + ; + +ILIKE + : 'ILIKE' + ; + +INNER_P + : 'INNER' + ; + +IS + : 'IS' + ; + +ISNULL + : 'ISNULL' + ; + +JOIN + : 'JOIN' + ; + +LEFT + : 'LEFT' + ; + +LIKE + : 'LIKE' + ; + +NATURAL + : 'NATURAL' + ; + +NOTNULL + : 'NOTNULL' + ; + +OUTER_P + : 'OUTER' + ; + +OVER + : 'OVER' + ; + +OVERLAPS + : 'OVERLAPS' + ; + +RIGHT + : 'RIGHT' + ; + +SIMILAR + : 'SIMILAR' + ; + +VERBOSE + : 'VERBOSE' + ; + // + + // non-reserved keywords + + // + +ABORT_P + : 'ABORT' + ; + +ABSOLUTE_P + : 'ABSOLUTE' + ; + +ACCESS + : 'ACCESS' + ; + +ACTION + : 'ACTION' + ; + +ADD_P + : 'ADD' + ; + +ADMIN + : 'ADMIN' + ; + +AFTER + : 'AFTER' + ; + +AGGREGATE + : 'AGGREGATE' + ; + +ALSO + : 'ALSO' + ; + +ALTER + : 'ALTER' + ; + +ALWAYS + : 'ALWAYS' + ; + +ASSERTION + : 'ASSERTION' + ; + +ASSIGNMENT + : 'ASSIGNMENT' + ; + +AT + : 'AT' + ; + +ATTRIBUTE + : 'ATTRIBUTE' + ; + +BACKWARD + : 'BACKWARD' + ; + +BEFORE + : 'BEFORE' + ; + +BEGIN_P + : 'BEGIN' + ; + +BY + : 'BY' + ; + +CACHE + : 'CACHE' + ; + +CALLED + : 'CALLED' + ; + +CASCADE + : 'CASCADE' + ; + +CASCADED + : 'CASCADED' + ; + +CATALOG + : 'CATALOG' + ; + +CHAIN + : 'CHAIN' + ; + +CHARACTERISTICS + : 'CHARACTERISTICS' + ; + +CHECKPOINT + : 'CHECKPOINT' + ; + +CLASS + : 'CLASS' + ; + +CLOSE + : 'CLOSE' + ; + +CLUSTER + : 'CLUSTER' + ; + +COMMENT + : 'COMMENT' + ; + +COMMENTS + : 'COMMENTS' + ; + +COMMIT + : 'COMMIT' + ; + +COMMITTED + : 'COMMITTED' + ; + +CONFIGURATION + : 'CONFIGURATION' + ; + +CONNECTION + : 'CONNECTION' + ; + +CONSTRAINTS + : 'CONSTRAINTS' + ; + +CONTENT_P + : 'CONTENT' + ; + +CONTINUE_P + : 'CONTINUE' + ; + +CONVERSION_P + : 'CONVERSION' + ; + +COPY + : 'COPY' + ; + +COST + : 'COST' + ; + +CSV + : 'CSV' + ; + +CURSOR + : 'CURSOR' + ; + +CYCLE + : 'CYCLE' + ; + +DATA_P + : 'DATA' + ; + +DATABASE + : 'DATABASE' + ; + +DAY_P + : 'DAY' + ; + +DEALLOCATE + : 'DEALLOCATE' + ; + +DECLARE + : 'DECLARE' + ; + +DEFAULTS + : 'DEFAULTS' + ; + +DEFERRED + : 'DEFERRED' + ; + +DEFINER + : 'DEFINER' + ; + +DELETE_P + : 'DELETE' + ; + +DELIMITER + : 'DELIMITER' + ; + +DELIMITERS + : 'DELIMITERS' + ; + +DICTIONARY + : 'DICTIONARY' + ; + +DISABLE_P + : 'DISABLE' + ; + +DISCARD + : 'DISCARD' + ; + +DOCUMENT_P + : 'DOCUMENT' + ; + +DOMAIN_P + : 'DOMAIN' + ; + +DOUBLE_P + : 'DOUBLE' + ; + +DROP + : 'DROP' + ; + +EACH + : 'EACH' + ; + +ENABLE_P + : 'ENABLE' + ; + +ENCODING + : 'ENCODING' + ; + +ENCRYPTED + : 'ENCRYPTED' + ; + +ENUM_P + : 'ENUM' + ; + +ESCAPE + : 'ESCAPE' + ; + +EVENT + : 'EVENT' + ; + +EXCLUDE + : 'EXCLUDE' + ; + +EXCLUDING + : 'EXCLUDING' + ; + +EXCLUSIVE + : 'EXCLUSIVE' + ; + +EXECUTE + : 'EXECUTE' + ; + +EXPLAIN + : 'EXPLAIN' + ; + +EXTENSION + : 'EXTENSION' + ; + +EXTERNAL + : 'EXTERNAL' + ; + +FAMILY + : 'FAMILY' + ; + +FIRST_P + : 'FIRST' + ; + +FOLLOWING + : 'FOLLOWING' + ; + +FORCE + : 'FORCE' + ; + +FORWARD + : 'FORWARD' + ; + +FUNCTION + : 'FUNCTION' + ; + +FUNCTIONS + : 'FUNCTIONS' + ; + +GLOBAL + : 'GLOBAL' + ; + +GRANTED + : 'GRANTED' + ; + +HANDLER + : 'HANDLER' + ; + +HEADER_P + : 'HEADER' + ; + +HOLD + : 'HOLD' + ; + +HOUR_P + : 'HOUR' + ; + +IDENTITY_P + : 'IDENTITY' + ; + +IF_P + : 'IF' + ; + +IMMEDIATE + : 'IMMEDIATE' + ; + +IMMUTABLE + : 'IMMUTABLE' + ; + +IMPLICIT_P + : 'IMPLICIT' + ; + +INCLUDING + : 'INCLUDING' + ; + +INCREMENT + : 'INCREMENT' + ; + +INDEX + : 'INDEX' + ; + +INDEXES + : 'INDEXES' + ; + +INHERIT + : 'INHERIT' + ; + +INHERITS + : 'INHERITS' + ; + +INLINE_P + : 'INLINE' + ; + +INSENSITIVE + : 'INSENSITIVE' + ; + +INSERT + : 'INSERT' + ; + +INSTEAD + : 'INSTEAD' + ; + +INVOKER + : 'INVOKER' + ; + +ISOLATION + : 'ISOLATION' + ; + +KEY + : 'KEY' + ; + +LABEL + : 'LABEL' + ; + +LANGUAGE + : 'LANGUAGE' + ; + +LARGE_P + : 'LARGE' + ; + +LAST_P + : 'LAST' + ; + //LC_COLLATE : 'LC'_'COLLATE; + + //LC_CTYPE : 'LC'_'CTYPE; + +LEAKPROOF + : 'LEAKPROOF' + ; + +LEVEL + : 'LEVEL' + ; + +LISTEN + : 'LISTEN' + ; + +LOAD + : 'LOAD' + ; + +LOCAL + : 'LOCAL' + ; + +LOCATION + : 'LOCATION' + ; + +LOCK_P + : 'LOCK' + ; + +MAPPING + : 'MAPPING' + ; + +MATCH + : 'MATCH' + ; + +MATERIALIZED + : 'MATERIALIZED' + ; + +MAXVALUE + : 'MAXVALUE' + ; + +MINUTE_P + : 'MINUTE' + ; + +MINVALUE + : 'MINVALUE' + ; + +MODE + : 'MODE' + ; + +MONTH_P + : 'MONTH' + ; + +MOVE + : 'MOVE' + ; + +NAME_P + : 'NAME' + ; + +NAMES + : 'NAMES' + ; + +NEXT + : 'NEXT' + ; + +NO + : 'NO' + ; + +NOTHING + : 'NOTHING' + ; + +NOTIFY + : 'NOTIFY' + ; + +NOWAIT + : 'NOWAIT' + ; + +NULLS_P + : 'NULLS' + ; + +OBJECT_P + : 'OBJECT' + ; + +OF + : 'OF' + ; + +OFF + : 'OFF' + ; + +OIDS + : 'OIDS' + ; + +OPERATOR + : 'OPERATOR' + ; + +OPTION + : 'OPTION' + ; + +OPTIONS + : 'OPTIONS' + ; + +OWNED + : 'OWNED' + ; + +OWNER + : 'OWNER' + ; + +PARSER + : 'PARSER' + ; + +PARTIAL + : 'PARTIAL' + ; + +PARTITION + : 'PARTITION' + ; + +PASSING + : 'PASSING' + ; + +PASSWORD + : 'PASSWORD' + ; + +PLANS + : 'PLANS' + ; + +PRECEDING + : 'PRECEDING' + ; + +PREPARE + : 'PREPARE' + ; + +PREPARED + : 'PREPARED' + ; + +PRESERVE + : 'PRESERVE' + ; + +PRIOR + : 'PRIOR' + ; + +PRIVILEGES + : 'PRIVILEGES' + ; + +PROCEDURAL + : 'PROCEDURAL' + ; + +PROCEDURE + : 'PROCEDURE' + ; + +PROGRAM + : 'PROGRAM' + ; + +QUOTE + : 'QUOTE' + ; + +RANGE + : 'RANGE' + ; + +READ + : 'READ' + ; + +REASSIGN + : 'REASSIGN' + ; + +RECHECK + : 'RECHECK' + ; + +RECURSIVE + : 'RECURSIVE' + ; + +REF + : 'REF' + ; + +REFRESH + : 'REFRESH' + ; + +REINDEX + : 'REINDEX' + ; + +RELATIVE_P + : 'RELATIVE' + ; + +RELEASE + : 'RELEASE' + ; + +RENAME + : 'RENAME' + ; + +REPEATABLE + : 'REPEATABLE' + ; + +REPLACE + : 'REPLACE' + ; + +REPLICA + : 'REPLICA' + ; + +RESET + : 'RESET' + ; + +RESTART + : 'RESTART' + ; + +RESTRICT + : 'RESTRICT' + ; + +RETURNS + : 'RETURNS' + ; + +REVOKE + : 'REVOKE' + ; + +ROLE + : 'ROLE' + ; + +ROLLBACK + : 'ROLLBACK' + ; + +ROWS + : 'ROWS' + ; + +RULE + : 'RULE' + ; + +SAVEPOINT + : 'SAVEPOINT' + ; + +SCHEMA + : 'SCHEMA' + ; + +SCROLL + : 'SCROLL' + ; + +SEARCH + : 'SEARCH' + ; + +SECOND_P + : 'SECOND' + ; + +SECURITY + : 'SECURITY' + ; + +SEQUENCE + : 'SEQUENCE' + ; + +SEQUENCES + : 'SEQUENCES' + ; + +SERIALIZABLE + : 'SERIALIZABLE' + ; + +SERVER + : 'SERVER' + ; + +SESSION + : 'SESSION' + ; + +SET + : 'SET' + ; + +SHARE + : 'SHARE' + ; + +SHOW + : 'SHOW' + ; + +SIMPLE + : 'SIMPLE' + ; + +SNAPSHOT + : 'SNAPSHOT' + ; + +STABLE + : 'STABLE' + ; + +STANDALONE_P + : 'STANDALONE' + ; + +START + : 'START' + ; + +STATEMENT + : 'STATEMENT' + ; + +STATISTICS + : 'STATISTICS' + ; + +STDIN + : 'STDIN' + ; + +STDOUT + : 'STDOUT' + ; + +STORAGE + : 'STORAGE' + ; + +STRICT_P + : 'STRICT' + ; + +STRIP_P + : 'STRIP' + ; + +SYSID + : 'SYSID' + ; + +SYSTEM_P + : 'SYSTEM' + ; + +TABLES + : 'TABLES' + ; + +TABLESPACE + : 'TABLESPACE' + ; + +TEMP + : 'TEMP' + ; + +TEMPLATE + : 'TEMPLATE' + ; + +TEMPORARY + : 'TEMPORARY' + ; + +TEXT_P + : 'TEXT' + ; + +TRANSACTION + : 'TRANSACTION' + ; + +TRIGGER + : 'TRIGGER' + ; + +TRUNCATE + : 'TRUNCATE' + ; + +TRUSTED + : 'TRUSTED' + ; + +TYPE_P + : 'TYPE' + ; + +TYPES_P + : 'TYPES' + ; + +UNBOUNDED + : 'UNBOUNDED' + ; + +UNCOMMITTED + : 'UNCOMMITTED' + ; + +UNENCRYPTED + : 'UNENCRYPTED' + ; + +UNKNOWN + : 'UNKNOWN' + ; + +UNLISTEN + : 'UNLISTEN' + ; + +UNLOGGED + : 'UNLOGGED' + ; + +UNTIL + : 'UNTIL' + ; + +UPDATE + : 'UPDATE' + ; + +VACUUM + : 'VACUUM' + ; + +VALID + : 'VALID' + ; + +VALIDATE + : 'VALIDATE' + ; + +VALIDATOR + : 'VALIDATOR' + ; + //VALUE : 'VALUE; + +VARYING + : 'VARYING' + ; + +VERSION_P + : 'VERSION' + ; + +VIEW + : 'VIEW' + ; + +VOLATILE + : 'VOLATILE' + ; + +WHITESPACE_P + : 'WHITESPACE' + ; + +WITHOUT + : 'WITHOUT' + ; + +WORK + : 'WORK' + ; + +WRAPPER + : 'WRAPPER' + ; + +WRITE + : 'WRITE' + ; + +XML_P + : 'XML' + ; + +YEAR_P + : 'YEAR' + ; + +YES_P + : 'YES' + ; + +ZONE + : 'ZONE' + ; + // + + // non-reserved keywords (can not be function or type) + + // + +BETWEEN + : 'BETWEEN' + ; + +BIGINT + : 'BIGINT' + ; + +BIT + : 'BIT' + ; + +BOOLEAN_P + : 'BOOLEAN' + ; + +CHAR_P + : 'CHAR' + ; + +CHARACTER + : 'CHARACTER' + ; + +COALESCE + : 'COALESCE' + ; + +DEC + : 'DEC' + ; + +DECIMAL_P + : 'DECIMAL' + ; + +EXISTS + : 'EXISTS' + ; + +EXTRACT + : 'EXTRACT' + ; + +FLOAT_P + : 'FLOAT' + ; + +GREATEST + : 'GREATEST' + ; + +INOUT + : 'INOUT' + ; + +INT_P + : 'INT' + ; + +INTEGER + : 'INTEGER' + ; + +INTERVAL + : 'INTERVAL' + ; + +LEAST + : 'LEAST' + ; + +NATIONAL + : 'NATIONAL' + ; + +NCHAR + : 'NCHAR' + ; + +NONE + : 'NONE' + ; + +NULLIF + : 'NULLIF' + ; + +NUMERIC + : 'NUMERIC' + ; + +OVERLAY + : 'OVERLAY' + ; + +POSITION + : 'POSITION' + ; + +PRECISION + : 'PRECISION' + ; + +REAL + : 'REAL' + ; + +ROW + : 'ROW' + ; + +SETOF + : 'SETOF' + ; + +SMALLINT + : 'SMALLINT' + ; + +SUBSTRING + : 'SUBSTRING' + ; + +TIME + : 'TIME' + ; + +TIMESTAMP + : 'TIMESTAMP' + ; + +TREAT + : 'TREAT' + ; + +TRIM + : 'TRIM' + ; + +VALUES + : 'VALUES' + ; + +VARCHAR + : 'VARCHAR' + ; + +XMLATTRIBUTES + : 'XMLATTRIBUTES' + ; + +XMLCONCAT + : 'XMLCONCAT' + ; + +XMLELEMENT + : 'XMLELEMENT' + ; + +XMLEXISTS + : 'XMLEXISTS' + ; + +XMLFOREST + : 'XMLFOREST' + ; + +XMLPARSE + : 'XMLPARSE' + ; + +XMLPI + : 'XMLPI' + ; + +XMLROOT + : 'XMLROOT' + ; + +XMLSERIALIZE + : 'XMLSERIALIZE' + ; + //MISSED + +CALL + : 'CALL' + ; + +CURRENT_P + : 'CURRENT' + ; + +ATTACH + : 'ATTACH' + ; + +DETACH + : 'DETACH' + ; + +EXPRESSION + : 'EXPRESSION' + ; + +GENERATED + : 'GENERATED' + ; + +LOGGED + : 'LOGGED' + ; + +STORED + : 'STORED' + ; + +INCLUDE + : 'INCLUDE' + ; + +ROUTINE + : 'ROUTINE' + ; + +TRANSFORM + : 'TRANSFORM' + ; + +IMPORT_P + : 'IMPORT' + ; + +POLICY + : 'POLICY' + ; + +METHOD + : 'METHOD' + ; + +REFERENCING + : 'REFERENCING' + ; + +NEW + : 'NEW' + ; + +OLD + : 'OLD' + ; + +VALUE_P + : 'VALUE' + ; + +SUBSCRIPTION + : 'SUBSCRIPTION' + ; + +PUBLICATION + : 'PUBLICATION' + ; + +OUT_P + : 'OUT' + ; + +END_P + : 'END' + ; + +ROUTINES + : 'ROUTINES' + ; + +SCHEMAS + : 'SCHEMAS' + ; + +PROCEDURES + : 'PROCEDURES' + ; + +INPUT_P + : 'INPUT' + ; + +SUPPORT + : 'SUPPORT' + ; + +PARALLEL + : 'PARALLEL' + ; + +SQL_P + : 'SQL' + ; + +DEPENDS + : 'DEPENDS' + ; + +OVERRIDING + : 'OVERRIDING' + ; + +CONFLICT + : 'CONFLICT' + ; + +SKIP_P + : 'SKIP' + ; + +LOCKED + : 'LOCKED' + ; + +TIES + : 'TIES' + ; + +ROLLUP + : 'ROLLUP' + ; + +CUBE + : 'CUBE' + ; + +GROUPING + : 'GROUPING' + ; + +SETS + : 'SETS' + ; + +TABLESAMPLE + : 'TABLESAMPLE' + ; + +ORDINALITY + : 'ORDINALITY' + ; + +XMLTABLE + : 'XMLTABLE' + ; + +COLUMNS + : 'COLUMNS' + ; + +XMLNAMESPACES + : 'XMLNAMESPACES' + ; + +ROWTYPE + : 'ROWTYPE' + ; + +NORMALIZED + : 'NORMALIZED' + ; + +WITHIN + : 'WITHIN' + ; + +FILTER + : 'FILTER' + ; + +GROUPS + : 'GROUPS' + ; + +OTHERS + : 'OTHERS' + ; + +NFC + : 'NFC' + ; + +NFD + : 'NFD' + ; + +NFKC + : 'NFKC' + ; + +NFKD + : 'NFKD' + ; + +UESCAPE + : 'UESCAPE' + ; + +VIEWS + : 'VIEWS' + ; + +NORMALIZE + : 'NORMALIZE' + ; + +DUMP + : 'DUMP' + ; + +PRINT_STRICT_PARAMS + : 'PRINT_STRICT_PARAMS' + ; + +VARIABLE_CONFLICT + : 'VARIABLE_CONFLICT' + ; + +ERROR + : 'ERROR' + ; + +USE_VARIABLE + : 'USE_VARIABLE' + ; + +USE_COLUMN + : 'USE_COLUMN' + ; + +ALIAS + : 'ALIAS' + ; + +CONSTANT + : 'CONSTANT' + ; + +PERFORM + : 'PERFORM' + ; + +GET + : 'GET' + ; + +DIAGNOSTICS + : 'DIAGNOSTICS' + ; + +STACKED + : 'STACKED' + ; + +ELSIF + : 'ELSIF' + ; + +WHILE + : 'WHILE' + ; + +REVERSE + : 'REVERSE' + ; + +FOREACH + : 'FOREACH' + ; + +SLICE + : 'SLICE' + ; + +EXIT + : 'EXIT' + ; + +RETURN + : 'RETURN' + ; + +QUERY + : 'QUERY' + ; + +RAISE + : 'RAISE' + ; + +SQLSTATE + : 'SQLSTATE' + ; + +DEBUG + : 'DEBUG' + ; + +LOG + : 'LOG' + ; + +INFO + : 'INFO' + ; + +NOTICE + : 'NOTICE' + ; + +WARNING + : 'WARNING' + ; + +EXCEPTION + : 'EXCEPTION' + ; + +ASSERT + : 'ASSERT' + ; + +LOOP + : 'LOOP' + ; + +OPEN + : 'OPEN' + ; + // + + // IDENTIFIERS (4.1.1) + + // + +Identifier + : IdentifierStartChar IdentifierChar* + ; + +fragment IdentifierStartChar + : // these are the valid identifier start characters below 0x7F + [a-zA-Z_] + | // these are the valid characters from 0x80 to 0xFF + [\u00AA\u00B5\u00BA\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF] + | // these are the letters above 0xFF which only need a single UTF-16 code unit + [\u0100-\uD7FF\uE000-\uFFFF] + {charIsLetter()}? + | // letters which require multiple UTF-16 code units + [\uD800-\uDBFF] [\uDC00-\uDFFF] + { + CheckIfUtf32Letter() + }? + + ; + +fragment IdentifierChar + : StrictIdentifierChar + | '$' + ; + +fragment StrictIdentifierChar + : IdentifierStartChar + | [0-9] + ; +/* Quoted Identifiers + * + * These are divided into four separate tokens, allowing distinction of valid quoted identifiers from invalid quoted + * identifiers without sacrificing the ability of the lexer to reliably recover from lexical errors in the input. + */ + + +QuotedIdentifier + : UnterminatedQuotedIdentifier '"' + ; + // This is a quoted identifier which only contains valid characters but is not terminated + +UnterminatedQuotedIdentifier + : '"' ('""' | ~ [\u0000"])* + ; + // This is a quoted identifier which is terminated but contains a \u0000 character + +InvalidQuotedIdentifier + : InvalidUnterminatedQuotedIdentifier '"' + ; + // This is a quoted identifier which is unterminated and contains a \u0000 character + +InvalidUnterminatedQuotedIdentifier + : '"' ('""' | ~ '"')* + ; +/* Unicode Quoted Identifiers + * + * These are divided into four separate tokens, allowing distinction of valid Unicode quoted identifiers from invalid + * Unicode quoted identifiers without sacrificing the ability of the lexer to reliably recover from lexical errors in + * the input. Note that escape sequences are never checked as part of this determination due to the ability of users + * to change the escape character with a UESCAPE clause following the Unicode quoted identifier. + * + * TODO: these rules assume "" is still a valid escape sequence within a Unicode quoted identifier. + */ + + +UnicodeQuotedIdentifier + : 'U' '&' QuotedIdentifier + ; + // This is a Unicode quoted identifier which only contains valid characters but is not terminated + +UnterminatedUnicodeQuotedIdentifier + : 'U' '&' UnterminatedQuotedIdentifier + ; + // This is a Unicode quoted identifier which is terminated but contains a \u0000 character + +InvalidUnicodeQuotedIdentifier + : 'U' '&' InvalidQuotedIdentifier + ; + // This is a Unicode quoted identifier which is unterminated and contains a \u0000 character + +InvalidUnterminatedUnicodeQuotedIdentifier + : 'U' '&' InvalidUnterminatedQuotedIdentifier + ; + // + + // CONSTANTS (4.1.2) + + // + + // String Constants (4.1.2.1) + +StringConstant + : UnterminatedStringConstant '\'' + ; + +UnterminatedStringConstant + : '\'' ('\'\'' | ~ '\'')* + ; + // String Constants with C-style Escapes (4.1.2.2) + +BeginEscapeStringConstant + : 'E' '\'' -> more , pushMode (EscapeStringConstantMode) + ; + // String Constants with Unicode Escapes (4.1.2.3) + + // + + // Note that escape sequences are never checked as part of this token due to the ability of users to change the escape + + // character with a UESCAPE clause following the Unicode string constant. + + // + + // TODO: these rules assume '' is still a valid escape sequence within a Unicode string constant. + +UnicodeEscapeStringConstant + : UnterminatedUnicodeEscapeStringConstant '\'' + ; + +UnterminatedUnicodeEscapeStringConstant + : 'U' '&' UnterminatedStringConstant + ; + // Dollar-quoted String Constants (4.1.2.4) + +BeginDollarStringConstant + : '$' Tag? '$' + {pushTag();} -> pushMode (DollarQuotedStringMode) + ; +/* "The tag, if any, of a dollar-quoted string follows the same rules as an + * unquoted identifier, except that it cannot contain a dollar sign." + */ + + +fragment Tag + : IdentifierStartChar StrictIdentifierChar* + ; + // Bit-strings Constants (4.1.2.5) + +BinaryStringConstant + : UnterminatedBinaryStringConstant '\'' + ; + +UnterminatedBinaryStringConstant + : 'B' '\'' [01]* + ; + +InvalidBinaryStringConstant + : InvalidUnterminatedBinaryStringConstant '\'' + ; + +InvalidUnterminatedBinaryStringConstant + : 'B' UnterminatedStringConstant + ; + +HexadecimalStringConstant + : UnterminatedHexadecimalStringConstant '\'' + ; + +UnterminatedHexadecimalStringConstant + : 'X' '\'' [0-9A-F]* + ; + +InvalidHexadecimalStringConstant + : InvalidUnterminatedHexadecimalStringConstant '\'' + ; + +InvalidUnterminatedHexadecimalStringConstant + : 'X' UnterminatedStringConstant + ; + // Numeric Constants (4.1.2.6) + +Integral + : Digits + ; + +NumericFail + : Digits '..' + {HandleNumericFail();} + ; + +Numeric + : Digits '.' Digits? /*? replaced with + to solve problem with DOT_DOT .. but this surely must be rewriten */ + + ('E' [+-]? Digits)? + | '.' Digits ('E' [+-]? Digits)? + | Digits 'E' [+-]? Digits + ; + +fragment Digits + : [0-9]+ + ; + +PLSQLVARIABLENAME + : ':' [A-Z_] [A-Z_0-9$]* + ; + +PLSQLIDENTIFIER + : ':"' ('\\' . | '""' | ~ ('"' | '\\'))* '"' + ; + // + + // WHITESPACE (4.1) + + // + +Whitespace + : [ \t]+ -> channel (HIDDEN) + ; + +Newline + : ('\r' '\n'? | '\n') -> channel (HIDDEN) + ; + // + + // COMMENTS (4.1.5) + + // + +LineComment + : '--' ~ [\r\n]* -> channel (HIDDEN) + ; + +BlockComment + : ('/*' ('/'* BlockComment | ~ [/*] | '/'+ ~ [/*] | '*'+ ~ [/*])* '*'* '*/') -> channel (HIDDEN) + ; + +UnterminatedBlockComment + : '/*' ('/'* BlockComment | // these characters are not part of special sequences in a block comment + ~ [/*] | // handle / or * characters which are not part of /* or */ and do not appear at the end of the file + ('/'+ ~ [/*] | '*'+ ~ [/*]))* + // Handle the case of / or * characters at the end of the file, or a nested unterminated block comment + ('/'+ | '*'+ | '/'* UnterminatedBlockComment)? + // Optional assertion to make sure this rule is working as intended + + { + UnterminatedBlockCommentDebugAssert(); + } + ; + // + + // META-COMMANDS + + // + + // http://www.postgresql.org/docs/9.3/static/app-psql.html + +MetaCommand + : '\\' (~ [\r\n\\"] | '"' ~ [\r\n"]* '"')* ('"' ~ [\r\n"]*)? + ; + +EndMetaCommand + : '\\\\' + ; + // + + // ERROR + + // + + // Any character which does not match one of the above rules will appear in the token stream as an ErrorCharacter token. + + // This ensures the lexer itself will never encounter a syntax error, so all error handling may be performed by the + + // parser. + +ErrorCharacter + : . + ; + +mode EscapeStringConstantMode; +EscapeStringConstant + : EscapeStringText '\'' -> mode (AfterEscapeStringConstantMode) + ; + +UnterminatedEscapeStringConstant + : EscapeStringText + // Handle a final unmatched \ character appearing at the end of the file + '\\'? EOF + ; + +fragment EscapeStringText + : ('\'\'' | '\\' ( // two-digit hex escapes are still valid when treated as single-digit escapes + 'x' [0-9a-fA-F] | + 'u' [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] | + 'U' [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] [0-9a-fA-F] | // Any character other than the Unicode escapes can follow a backslash. Some have special meaning, + // but that doesn't affect the syntax. + ~ [xuU]) | ~ ['\\])* + ; + +InvalidEscapeStringConstant + : InvalidEscapeStringText '\'' -> mode (AfterEscapeStringConstantMode) + ; + +InvalidUnterminatedEscapeStringConstant + : InvalidEscapeStringText + // Handle a final unmatched \ character appearing at the end of the file + '\\'? EOF + ; + +fragment InvalidEscapeStringText + : ('\'\'' | '\\' . | ~ ['\\])* + ; + +mode AfterEscapeStringConstantMode; +AfterEscapeStringConstantMode_Whitespace + : Whitespace -> type (Whitespace) , channel (HIDDEN) + ; + +AfterEscapeStringConstantMode_Newline + : Newline -> type (Newline) , channel (HIDDEN) , mode (AfterEscapeStringConstantWithNewlineMode) + ; + +AfterEscapeStringConstantMode_NotContinued + : + {} // intentionally empty + -> skip , popMode + ; + +mode AfterEscapeStringConstantWithNewlineMode; +AfterEscapeStringConstantWithNewlineMode_Whitespace + : Whitespace -> type (Whitespace) , channel (HIDDEN) + ; + +AfterEscapeStringConstantWithNewlineMode_Newline + : Newline -> type (Newline) , channel (HIDDEN) + ; + +AfterEscapeStringConstantWithNewlineMode_Continued + : '\'' -> more , mode (EscapeStringConstantMode) + ; + +AfterEscapeStringConstantWithNewlineMode_NotContinued + : + {} // intentionally empty + -> skip , popMode + ; + +mode DollarQuotedStringMode; +DollarText + : ~ '$'+ + //| '$'([0-9])+ + | // this alternative improves the efficiency of handling $ characters within a dollar-quoted string which are + + // not part of the ending tag. + '$' ~ '$'* + ; + +EndDollarStringConstant + : ('$' Tag? '$') + {isTag()}? + {popTag();} -> popMode + ; + diff --git a/src/grammar/pgsql/PostgreSQLParser.g4 b/src/grammar/pgsql/PostgreSQLParser.g4 new file mode 100644 index 0000000..3f62833 --- /dev/null +++ b/src/grammar/pgsql/PostgreSQLParser.g4 @@ -0,0 +1,5327 @@ +parser grammar PostgreSQLParser; + + +options { tokenVocab = PostgreSQLLexer; +superClass = PostgreSQLParserBase; +} + + +@header +{ +} +@members +{ +} +root + : stmtblock EOF + ; + +plsqlroot + : pl_function + ; + +stmtblock + : stmtmulti + ; + +stmtmulti + : (stmt SEMI?)* + ; + +stmt + : altereventtrigstmt + | altercollationstmt + | alterdatabasestmt + | alterdatabasesetstmt + | alterdefaultprivilegesstmt + | alterdomainstmt + | alterenumstmt + | alterextensionstmt + | alterextensioncontentsstmt + | alterfdwstmt + | alterforeignserverstmt + | alterfunctionstmt + | altergroupstmt + | alterobjectdependsstmt + | alterobjectschemastmt + | alterownerstmt + | alteroperatorstmt + | altertypestmt + | alterpolicystmt + | alterseqstmt + | altersystemstmt + | altertablestmt + | altertblspcstmt + | altercompositetypestmt + | alterpublicationstmt + | alterrolesetstmt + | alterrolestmt + | altersubscriptionstmt + | alterstatsstmt + | altertsconfigurationstmt + | altertsdictionarystmt + | alterusermappingstmt + | analyzestmt + | callstmt + | checkpointstmt + | closeportalstmt + | clusterstmt + | commentstmt + | constraintssetstmt + | copystmt + | createamstmt + | createasstmt + | createassertionstmt + | createcaststmt + | createconversionstmt + | createdomainstmt + | createextensionstmt + | createfdwstmt + | createforeignserverstmt + | createforeigntablestmt + | createfunctionstmt + | creategroupstmt + | creatematviewstmt + | createopclassstmt + | createopfamilystmt + | createpublicationstmt + | alteropfamilystmt + | createpolicystmt + | createplangstmt + | createschemastmt + | createseqstmt + | createstmt + | createsubscriptionstmt + | createstatsstmt + | createtablespacestmt + | createtransformstmt + | createtrigstmt + | createeventtrigstmt + | createrolestmt + | createuserstmt + | createusermappingstmt + | createdbstmt + | deallocatestmt + | declarecursorstmt + | definestmt + | deletestmt + | discardstmt + | dostmt + | dropcaststmt + | dropopclassstmt + | dropopfamilystmt + | dropownedstmt + | dropstmt + | dropsubscriptionstmt + | droptablespacestmt + | droptransformstmt + | droprolestmt + | dropusermappingstmt + | dropdbstmt + | executestmt + | explainstmt + | fetchstmt + | grantstmt + | grantrolestmt + | importforeignschemastmt + | indexstmt + | insertstmt + | listenstmt + | refreshmatviewstmt + | loadstmt + | lockstmt + | notifystmt + | preparestmt + | reassignownedstmt + | reindexstmt + | removeaggrstmt + | removefuncstmt + | removeoperstmt + | renamestmt + | revokestmt + | revokerolestmt + | rulestmt + | seclabelstmt + | selectstmt + | transactionstmt + | truncatestmt + | unlistenstmt + | updatestmt + | vacuumstmt + | variableresetstmt + | variablesetstmt + | variableshowstmt + | viewstmt + | plsqlconsolecommand + ; + +plsqlconsolecommand + : MetaCommand EndMetaCommand? + ; + +callstmt + : CALL func_application + ; + +createrolestmt + : CREATE ROLE roleid opt_with optrolelist + ; + +opt_with + : WITH + //| WITH_LA + | + ; + +optrolelist + : createoptroleelem* + ; + +alteroptrolelist + : alteroptroleelem* + ; + +alteroptroleelem + : PASSWORD (sconst | NULL_P) + | (ENCRYPTED | UNENCRYPTED) PASSWORD sconst + | INHERIT + | CONNECTION LIMIT signediconst + | VALID UNTIL sconst + | USER role_list + | identifier + ; + +createoptroleelem + : alteroptroleelem + | SYSID iconst + | ADMIN role_list + | ROLE role_list + | IN_P (ROLE | GROUP_P) role_list + ; + +createuserstmt + : CREATE USER roleid opt_with optrolelist + ; + +alterrolestmt + : ALTER (ROLE | USER) rolespec opt_with alteroptrolelist + ; + +opt_in_database + : + | IN_P DATABASE name + ; + +alterrolesetstmt + : ALTER (ROLE | USER) ALL? rolespec opt_in_database setresetclause + ; + +droprolestmt + : DROP (ROLE | USER | GROUP_P) (IF_P EXISTS)? role_list + ; + +creategroupstmt + : CREATE GROUP_P roleid opt_with optrolelist + ; + +altergroupstmt + : ALTER GROUP_P rolespec add_drop USER role_list + ; + +add_drop + : ADD_P + | DROP + ; + +createschemastmt + : CREATE SCHEMA (IF_P NOT EXISTS)? (optschemaname AUTHORIZATION rolespec | colid) optschemaeltlist + ; + +optschemaname + : colid + | + ; + +optschemaeltlist + : schema_stmt* + ; + +schema_stmt + : createstmt + | indexstmt + | createseqstmt + | createtrigstmt + | grantstmt + | viewstmt + ; + +variablesetstmt + : SET (LOCAL | SESSION)? set_rest + ; + +set_rest + : TRANSACTION transaction_mode_list + | SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list + | set_rest_more + ; + +generic_set + : var_name (TO | EQUAL) var_list + ; + +set_rest_more + : generic_set + | var_name FROM CURRENT_P + | TIME ZONE zone_value + | CATALOG sconst + | SCHEMA sconst + | NAMES opt_encoding + | ROLE nonreservedword_or_sconst + | SESSION AUTHORIZATION nonreservedword_or_sconst + | XML_P OPTION document_or_content + | TRANSACTION SNAPSHOT sconst + ; + +var_name + : colid (DOT colid)* + ; + +var_list + : var_value (COMMA var_value)* + ; + +var_value + : opt_boolean_or_string + | numericonly + ; + +iso_level + : READ (UNCOMMITTED | COMMITTED) + | REPEATABLE READ + | SERIALIZABLE + ; + +opt_boolean_or_string + : TRUE_P + | FALSE_P + | ON + | nonreservedword_or_sconst + ; + +zone_value + : sconst + | identifier + | constinterval sconst opt_interval + | constinterval OPEN_PAREN iconst CLOSE_PAREN sconst + | numericonly + | DEFAULT + | LOCAL + ; + +opt_encoding + : sconst + | DEFAULT + | + ; + +nonreservedword_or_sconst + : nonreservedword + | sconst + ; + +variableresetstmt + : RESET reset_rest + ; + +reset_rest + : generic_reset + | TIME ZONE + | TRANSACTION ISOLATION LEVEL + | SESSION AUTHORIZATION + ; + +generic_reset + : var_name + | ALL + ; + +setresetclause + : SET set_rest + | variableresetstmt + ; + +functionsetresetclause + : SET set_rest_more + | variableresetstmt + ; + +variableshowstmt + : SHOW (var_name | TIME ZONE | TRANSACTION ISOLATION LEVEL | SESSION AUTHORIZATION | ALL) + ; + +constraintssetstmt + : SET CONSTRAINTS constraints_set_list constraints_set_mode + ; + +constraints_set_list + : ALL + | qualified_name_list + ; + +constraints_set_mode + : DEFERRED + | IMMEDIATE + ; + +checkpointstmt + : CHECKPOINT + ; + +discardstmt + : DISCARD (ALL | TEMP | TEMPORARY | PLANS | SEQUENCES) + ; + +altertablestmt + : ALTER TABLE (IF_P EXISTS)? relation_expr (alter_table_cmds | partition_cmd) + | ALTER TABLE ALL IN_P TABLESPACE name (OWNED BY role_list)? SET TABLESPACE name opt_nowait + | ALTER INDEX (IF_P EXISTS)? qualified_name (alter_table_cmds | index_partition_cmd) + | ALTER INDEX ALL IN_P TABLESPACE name (OWNED BY role_list)? SET TABLESPACE name opt_nowait + | ALTER SEQUENCE (IF_P EXISTS)? qualified_name alter_table_cmds + | ALTER VIEW (IF_P EXISTS)? qualified_name alter_table_cmds + | ALTER MATERIALIZED VIEW (IF_P EXISTS)? qualified_name alter_table_cmds + | ALTER MATERIALIZED VIEW ALL IN_P TABLESPACE name (OWNED BY role_list)? SET TABLESPACE name opt_nowait + | ALTER FOREIGN TABLE (IF_P EXISTS)? relation_expr alter_table_cmds + ; + +alter_table_cmds + : alter_table_cmd (COMMA alter_table_cmd)* + ; + +partition_cmd + : ATTACH PARTITION qualified_name partitionboundspec + | DETACH PARTITION qualified_name + ; + +index_partition_cmd + : ATTACH PARTITION qualified_name + ; + +alter_table_cmd + : ADD_P columnDef + | ADD_P IF_P NOT EXISTS columnDef + | ADD_P COLUMN columnDef + | ADD_P COLUMN IF_P NOT EXISTS columnDef + | ALTER opt_column colid alter_column_default + | ALTER opt_column colid DROP NOT NULL_P + | ALTER opt_column colid SET NOT NULL_P + | ALTER opt_column colid DROP EXPRESSION + | ALTER opt_column colid DROP EXPRESSION IF_P EXISTS + | ALTER opt_column colid SET STATISTICS signediconst + | ALTER opt_column iconst SET STATISTICS signediconst + | ALTER opt_column colid SET reloptions + | ALTER opt_column colid RESET reloptions + | ALTER opt_column colid SET STORAGE colid + | ALTER opt_column colid ADD_P GENERATED generated_when AS IDENTITY_P optparenthesizedseqoptlist + | ALTER opt_column colid alter_identity_column_option_list + | ALTER opt_column colid DROP IDENTITY_P + | ALTER opt_column colid DROP IDENTITY_P IF_P EXISTS + | DROP opt_column IF_P EXISTS colid opt_drop_behavior + | DROP opt_column colid opt_drop_behavior + | ALTER opt_column colid opt_set_data TYPE_P typename opt_collate_clause alter_using + | ALTER opt_column colid alter_generic_options + | ADD_P tableconstraint + | ALTER CONSTRAINT name constraintattributespec + | VALIDATE CONSTRAINT name + | DROP CONSTRAINT IF_P EXISTS name opt_drop_behavior + | DROP CONSTRAINT name opt_drop_behavior + | SET WITHOUT OIDS + | CLUSTER ON name + | SET WITHOUT CLUSTER + | SET LOGGED + | SET UNLOGGED + | ENABLE_P TRIGGER name + | ENABLE_P ALWAYS TRIGGER name + | ENABLE_P REPLICA TRIGGER name + | ENABLE_P TRIGGER ALL + | ENABLE_P TRIGGER USER + | DISABLE_P TRIGGER name + | DISABLE_P TRIGGER ALL + | DISABLE_P TRIGGER USER + | ENABLE_P RULE name + | ENABLE_P ALWAYS RULE name + | ENABLE_P REPLICA RULE name + | DISABLE_P RULE name + | INHERIT qualified_name + | NO INHERIT qualified_name + | OF any_name + | NOT OF + | OWNER TO rolespec + | SET TABLESPACE name + | SET reloptions + | RESET reloptions + | REPLICA IDENTITY_P replica_identity + | ENABLE_P ROW LEVEL SECURITY + | DISABLE_P ROW LEVEL SECURITY + | FORCE ROW LEVEL SECURITY + | NO FORCE ROW LEVEL SECURITY + | alter_generic_options + ; + +alter_column_default + : SET DEFAULT a_expr + | DROP DEFAULT + ; + +opt_drop_behavior + : CASCADE + | RESTRICT + | + ; + +opt_collate_clause + : COLLATE any_name + | + ; + +alter_using + : USING a_expr + | + ; + +replica_identity + : NOTHING + | FULL + | DEFAULT + | USING INDEX name + ; + +reloptions + : OPEN_PAREN reloption_list CLOSE_PAREN + ; + +opt_reloptions + : WITH reloptions + | + ; + +reloption_list + : reloption_elem (COMMA reloption_elem)* + ; + +reloption_elem + : collabel (EQUAL def_arg | DOT collabel (EQUAL def_arg)?)? + ; + +alter_identity_column_option_list + : alter_identity_column_option+ + ; + +alter_identity_column_option + : RESTART (opt_with numericonly)? + | SET (seqoptelem | GENERATED generated_when) + ; + +partitionboundspec + : FOR VALUES WITH OPEN_PAREN hash_partbound CLOSE_PAREN + | FOR VALUES IN_P OPEN_PAREN expr_list CLOSE_PAREN + | FOR VALUES FROM OPEN_PAREN expr_list CLOSE_PAREN TO OPEN_PAREN expr_list CLOSE_PAREN + | DEFAULT + ; + +hash_partbound_elem + : nonreservedword iconst + ; + +hash_partbound + : hash_partbound_elem (COMMA hash_partbound_elem)* + ; + +altercompositetypestmt + : ALTER TYPE_P any_name alter_type_cmds + ; + +alter_type_cmds + : alter_type_cmd (COMMA alter_type_cmd)* + ; + +alter_type_cmd + : ADD_P ATTRIBUTE tablefuncelement opt_drop_behavior + | DROP ATTRIBUTE (IF_P EXISTS)? colid opt_drop_behavior + | ALTER ATTRIBUTE colid opt_set_data TYPE_P typename opt_collate_clause opt_drop_behavior + ; + +closeportalstmt + : CLOSE (cursor_name | ALL) + ; + +copystmt + : COPY opt_binary qualified_name opt_column_list copy_from opt_program copy_file_name copy_delimiter opt_with copy_options where_clause + | COPY OPEN_PAREN preparablestmt CLOSE_PAREN TO opt_program copy_file_name opt_with copy_options + ; + +copy_from + : FROM + | TO + ; + +opt_program + : PROGRAM + | + ; + +copy_file_name + : sconst + | STDIN + | STDOUT + ; + +copy_options + : copy_opt_list + | OPEN_PAREN copy_generic_opt_list CLOSE_PAREN + ; + +copy_opt_list + : copy_opt_item* + ; + +copy_opt_item + : BINARY + | FREEZE + | DELIMITER opt_as sconst + | NULL_P opt_as sconst + | CSV + | HEADER_P + | QUOTE opt_as sconst + | ESCAPE opt_as sconst + | FORCE QUOTE columnlist + | FORCE QUOTE STAR + | FORCE NOT NULL_P columnlist + | FORCE NULL_P columnlist + | ENCODING sconst + ; + +opt_binary + : BINARY + | + ; + +copy_delimiter + : opt_using DELIMITERS sconst + | + ; + +opt_using + : USING + | + ; + +copy_generic_opt_list + : copy_generic_opt_elem (COMMA copy_generic_opt_elem)* + ; + +copy_generic_opt_elem + : collabel copy_generic_opt_arg + ; + +copy_generic_opt_arg + : opt_boolean_or_string + | numericonly + | STAR + | OPEN_PAREN copy_generic_opt_arg_list CLOSE_PAREN + | + ; + +copy_generic_opt_arg_list + : copy_generic_opt_arg_list_item (COMMA copy_generic_opt_arg_list_item)* + ; + +copy_generic_opt_arg_list_item + : opt_boolean_or_string + ; + +createstmt + : CREATE opttemp TABLE (IF_P NOT EXISTS)? qualified_name (OPEN_PAREN opttableelementlist CLOSE_PAREN optinherit optpartitionspec table_access_method_clause optwith oncommitoption opttablespace | OF any_name opttypedtableelementlist optpartitionspec table_access_method_clause optwith oncommitoption opttablespace | PARTITION OF qualified_name opttypedtableelementlist partitionboundspec optpartitionspec table_access_method_clause optwith oncommitoption opttablespace) + ; + +opttemp + : TEMPORARY + | TEMP + | LOCAL (TEMPORARY | TEMP) + | GLOBAL (TEMPORARY | TEMP) + | UNLOGGED + | + ; + +opttableelementlist + : tableelementlist + | + ; + +opttypedtableelementlist + : OPEN_PAREN typedtableelementlist CLOSE_PAREN + | + ; + +tableelementlist + : tableelement (COMMA tableelement)* + ; + +typedtableelementlist + : typedtableelement (COMMA typedtableelement)* + ; + +tableelement + : columnDef + | tablelikeclause + | tableconstraint + ; + +typedtableelement + : columnOptions + | tableconstraint + ; + +columnDef + : colid typename create_generic_options colquallist + ; + +columnOptions + : colid (WITH OPTIONS)? colquallist + ; + +colquallist + : colconstraint* + ; + +colconstraint + : CONSTRAINT name colconstraintelem + | colconstraintelem + | constraintattr + | COLLATE any_name + ; + +colconstraintelem + : NOT NULL_P + | NULL_P + | UNIQUE opt_definition optconstablespace + | PRIMARY KEY opt_definition optconstablespace + | CHECK OPEN_PAREN a_expr CLOSE_PAREN opt_no_inherit + | DEFAULT b_expr + | GENERATED generated_when AS (IDENTITY_P optparenthesizedseqoptlist | OPEN_PAREN a_expr CLOSE_PAREN STORED) + | REFERENCES qualified_name opt_column_list key_match key_actions + ; + +generated_when + : ALWAYS + | BY DEFAULT + ; + +constraintattr + : DEFERRABLE + | NOT DEFERRABLE + | INITIALLY (DEFERRED | IMMEDIATE) + ; + +tablelikeclause + : LIKE qualified_name tablelikeoptionlist + ; + +tablelikeoptionlist + : ((INCLUDING | EXCLUDING) tablelikeoption)* + ; + +tablelikeoption + : COMMENTS + | CONSTRAINTS + | DEFAULTS + | IDENTITY_P + | GENERATED + | INDEXES + | STATISTICS + | STORAGE + | ALL + ; + +tableconstraint + : CONSTRAINT name constraintelem + | constraintelem + ; + +constraintelem + : CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec + | UNIQUE (OPEN_PAREN columnlist CLOSE_PAREN opt_c_include opt_definition optconstablespace constraintattributespec | existingindex constraintattributespec) + | PRIMARY KEY (OPEN_PAREN columnlist CLOSE_PAREN opt_c_include opt_definition optconstablespace constraintattributespec | existingindex constraintattributespec) + | EXCLUDE access_method_clause OPEN_PAREN exclusionconstraintlist CLOSE_PAREN opt_c_include opt_definition optconstablespace exclusionwhereclause constraintattributespec + | FOREIGN KEY OPEN_PAREN columnlist CLOSE_PAREN REFERENCES qualified_name opt_column_list key_match key_actions constraintattributespec + ; + +opt_no_inherit + : NO INHERIT + | + ; + +opt_column_list + : OPEN_PAREN columnlist CLOSE_PAREN + | + ; + +columnlist + : columnElem (COMMA columnElem)* + ; + +columnElem + : colid + ; + +opt_c_include + : INCLUDE OPEN_PAREN columnlist CLOSE_PAREN + | + ; + +key_match + : MATCH (FULL | PARTIAL | SIMPLE) + | + ; + +exclusionconstraintlist + : exclusionconstraintelem (COMMA exclusionconstraintelem)* + ; + +exclusionconstraintelem + : index_elem WITH (any_operator | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN) + ; + +exclusionwhereclause + : WHERE OPEN_PAREN a_expr CLOSE_PAREN + | + ; + +key_actions + : key_update + | key_delete + | key_update key_delete + | key_delete key_update + | + ; + +key_update + : ON UPDATE key_action + ; + +key_delete + : ON DELETE_P key_action + ; + +key_action + : NO ACTION + | RESTRICT + | CASCADE + | SET (NULL_P | DEFAULT) + ; + +optinherit + : INHERITS OPEN_PAREN qualified_name_list CLOSE_PAREN + | + ; + +optpartitionspec + : partitionspec + | + ; + +partitionspec + : PARTITION BY colid OPEN_PAREN part_params CLOSE_PAREN + ; + +part_params + : part_elem (COMMA part_elem)* + ; + +part_elem + : colid opt_collate opt_class + | func_expr_windowless opt_collate opt_class + | OPEN_PAREN a_expr CLOSE_PAREN opt_collate opt_class + ; + +table_access_method_clause + : USING name + | + ; + +optwith + : WITH reloptions + | WITHOUT OIDS + | + ; + +oncommitoption + : ON COMMIT (DROP | DELETE_P ROWS | PRESERVE ROWS) + | + ; + +opttablespace + : TABLESPACE name + | + ; + +optconstablespace + : USING INDEX TABLESPACE name + | + ; + +existingindex + : USING INDEX name + ; + +createstatsstmt + : CREATE STATISTICS (IF_P NOT EXISTS)? any_name opt_name_list ON expr_list FROM from_list + ; + +alterstatsstmt + : ALTER STATISTICS (IF_P EXISTS)? any_name SET STATISTICS signediconst + ; + +createasstmt + : CREATE opttemp TABLE (IF_P NOT EXISTS)? create_as_target AS selectstmt opt_with_data + ; + +create_as_target + : qualified_name opt_column_list table_access_method_clause optwith oncommitoption opttablespace + ; + +opt_with_data + : WITH (DATA_P | NO DATA_P) + | + ; + +creatematviewstmt + : CREATE optnolog MATERIALIZED VIEW (IF_P NOT EXISTS)? create_mv_target AS selectstmt opt_with_data + ; + +create_mv_target + : qualified_name opt_column_list table_access_method_clause opt_reloptions opttablespace + ; + +optnolog + : UNLOGGED + | + ; + +refreshmatviewstmt + : REFRESH MATERIALIZED VIEW opt_concurrently qualified_name opt_with_data + ; + +createseqstmt + : CREATE opttemp SEQUENCE (IF_P NOT EXISTS)? qualified_name optseqoptlist + ; + +alterseqstmt + : ALTER SEQUENCE (IF_P EXISTS)? qualified_name seqoptlist + ; + +optseqoptlist + : seqoptlist + | + ; + +optparenthesizedseqoptlist + : OPEN_PAREN seqoptlist CLOSE_PAREN + | + ; + +seqoptlist + : seqoptelem+ + ; + +seqoptelem + : AS simpletypename + | CACHE numericonly + | CYCLE + | INCREMENT opt_by numericonly + | MAXVALUE numericonly + | MINVALUE numericonly + | NO (MAXVALUE | MINVALUE | CYCLE) + | OWNED BY any_name + | SEQUENCE NAME_P any_name + | START opt_with numericonly + | RESTART opt_with numericonly? + ; + +opt_by + : BY + | + ; + +numericonly + : fconst + | PLUS fconst + | MINUS fconst + | signediconst + ; + +numericonly_list + : numericonly (COMMA numericonly)* + ; + +createplangstmt + : CREATE opt_or_replace opt_trusted opt_procedural LANGUAGE name (HANDLER handler_name opt_inline_handler opt_validator)? + ; + +opt_trusted + : TRUSTED + | + ; + +handler_name + : name attrs? + ; + +opt_inline_handler + : INLINE_P handler_name + | + ; + +validator_clause + : VALIDATOR handler_name + | NO VALIDATOR + ; + +opt_validator + : validator_clause + | + ; + +opt_procedural + : PROCEDURAL + | + ; + +createtablespacestmt + : CREATE TABLESPACE name opttablespaceowner LOCATION sconst opt_reloptions + ; + +opttablespaceowner + : OWNER rolespec + | + ; + +droptablespacestmt + : DROP TABLESPACE (IF_P EXISTS)? name + ; + +createextensionstmt + : CREATE EXTENSION (IF_P NOT EXISTS)? name opt_with create_extension_opt_list + ; + +create_extension_opt_list + : create_extension_opt_item* + ; + +create_extension_opt_item + : SCHEMA name + | VERSION_P nonreservedword_or_sconst + | FROM nonreservedword_or_sconst + | CASCADE + ; + +alterextensionstmt + : ALTER EXTENSION name UPDATE alter_extension_opt_list + ; + +alter_extension_opt_list + : alter_extension_opt_item* + ; + +alter_extension_opt_item + : TO nonreservedword_or_sconst + ; + +alterextensioncontentsstmt + : ALTER EXTENSION name add_drop object_type_name name + | ALTER EXTENSION name add_drop object_type_any_name any_name + | ALTER EXTENSION name add_drop AGGREGATE aggregate_with_argtypes + | ALTER EXTENSION name add_drop CAST OPEN_PAREN typename AS typename CLOSE_PAREN + | ALTER EXTENSION name add_drop DOMAIN_P typename + | ALTER EXTENSION name add_drop FUNCTION function_with_argtypes + | ALTER EXTENSION name add_drop OPERATOR operator_with_argtypes + | ALTER EXTENSION name add_drop OPERATOR CLASS any_name USING name + | ALTER EXTENSION name add_drop OPERATOR FAMILY any_name USING name + | ALTER EXTENSION name add_drop PROCEDURE function_with_argtypes + | ALTER EXTENSION name add_drop ROUTINE function_with_argtypes + | ALTER EXTENSION name add_drop TRANSFORM FOR typename LANGUAGE name + | ALTER EXTENSION name add_drop TYPE_P typename + ; + +createfdwstmt + : CREATE FOREIGN DATA_P WRAPPER name opt_fdw_options create_generic_options + ; + +fdw_option + : HANDLER handler_name + | NO HANDLER + | VALIDATOR handler_name + | NO VALIDATOR + ; + +fdw_options + : fdw_option+ + ; + +opt_fdw_options + : fdw_options + | + ; + +alterfdwstmt + : ALTER FOREIGN DATA_P WRAPPER name opt_fdw_options alter_generic_options + | ALTER FOREIGN DATA_P WRAPPER name fdw_options + ; + +create_generic_options + : OPTIONS OPEN_PAREN generic_option_list CLOSE_PAREN + | + ; + +generic_option_list + : generic_option_elem (COMMA generic_option_elem)* + ; + +alter_generic_options + : OPTIONS OPEN_PAREN alter_generic_option_list CLOSE_PAREN + ; + +alter_generic_option_list + : alter_generic_option_elem (COMMA alter_generic_option_elem)* + ; + +alter_generic_option_elem + : generic_option_elem + | SET generic_option_elem + | ADD_P generic_option_elem + | DROP generic_option_name + ; + +generic_option_elem + : generic_option_name generic_option_arg + ; + +generic_option_name + : collabel + ; + +generic_option_arg + : sconst + ; + +createforeignserverstmt + : CREATE SERVER name opt_type opt_foreign_server_version FOREIGN DATA_P WRAPPER name create_generic_options + | CREATE SERVER IF_P NOT EXISTS name opt_type opt_foreign_server_version FOREIGN DATA_P WRAPPER name create_generic_options + ; + +opt_type + : TYPE_P sconst + | + ; + +foreign_server_version + : VERSION_P (sconst | NULL_P) + ; + +opt_foreign_server_version + : foreign_server_version + | + ; + +alterforeignserverstmt + : ALTER SERVER name (alter_generic_options | foreign_server_version alter_generic_options?) + ; + +createforeigntablestmt + : CREATE FOREIGN TABLE qualified_name OPEN_PAREN opttableelementlist CLOSE_PAREN optinherit SERVER name create_generic_options + | CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name OPEN_PAREN opttableelementlist CLOSE_PAREN optinherit SERVER name create_generic_options + | CREATE FOREIGN TABLE qualified_name PARTITION OF qualified_name opttypedtableelementlist partitionboundspec SERVER name create_generic_options + | CREATE FOREIGN TABLE IF_P NOT EXISTS qualified_name PARTITION OF qualified_name opttypedtableelementlist partitionboundspec SERVER name create_generic_options + ; + +importforeignschemastmt + : IMPORT_P FOREIGN SCHEMA name import_qualification FROM SERVER name INTO name create_generic_options + ; + +import_qualification_type + : LIMIT TO + | EXCEPT + ; + +import_qualification + : import_qualification_type OPEN_PAREN relation_expr_list CLOSE_PAREN + | + ; + +createusermappingstmt + : CREATE USER MAPPING FOR auth_ident SERVER name create_generic_options + | CREATE USER MAPPING IF_P NOT EXISTS FOR auth_ident SERVER name create_generic_options + ; + +auth_ident + : rolespec + | USER + ; + +dropusermappingstmt + : DROP USER MAPPING FOR auth_ident SERVER name + | DROP USER MAPPING IF_P EXISTS FOR auth_ident SERVER name + ; + +alterusermappingstmt + : ALTER USER MAPPING FOR auth_ident SERVER name alter_generic_options + ; + +createpolicystmt + : CREATE POLICY name ON qualified_name rowsecuritydefaultpermissive rowsecuritydefaultforcmd rowsecuritydefaulttorole rowsecurityoptionalexpr rowsecurityoptionalwithcheck + ; + +alterpolicystmt + : ALTER POLICY name ON qualified_name rowsecurityoptionaltorole rowsecurityoptionalexpr rowsecurityoptionalwithcheck + ; + +rowsecurityoptionalexpr + : USING OPEN_PAREN a_expr CLOSE_PAREN + | + ; + +rowsecurityoptionalwithcheck + : WITH CHECK OPEN_PAREN a_expr CLOSE_PAREN + | + ; + +rowsecuritydefaulttorole + : TO role_list + | + ; + +rowsecurityoptionaltorole + : TO role_list + | + ; + +rowsecuritydefaultpermissive + : AS identifier + | + ; + +rowsecuritydefaultforcmd + : FOR row_security_cmd + | + ; + +row_security_cmd + : ALL + | SELECT + | INSERT + | UPDATE + | DELETE_P + ; + +createamstmt + : CREATE ACCESS METHOD name TYPE_P am_type HANDLER handler_name + ; + +am_type + : INDEX + | TABLE + ; + +createtrigstmt + : CREATE TRIGGER name triggeractiontime triggerevents ON qualified_name triggerreferencing triggerforspec triggerwhen EXECUTE function_or_procedure func_name OPEN_PAREN triggerfuncargs CLOSE_PAREN + | CREATE CONSTRAINT TRIGGER name AFTER triggerevents ON qualified_name optconstrfromtable constraintattributespec FOR EACH ROW triggerwhen EXECUTE function_or_procedure func_name OPEN_PAREN triggerfuncargs CLOSE_PAREN + ; + +triggeractiontime + : BEFORE + | AFTER + | INSTEAD OF + ; + +triggerevents + : triggeroneevent (OR triggeroneevent)* + ; + +triggeroneevent + : INSERT + | DELETE_P + | UPDATE + | UPDATE OF columnlist + | TRUNCATE + ; + +triggerreferencing + : REFERENCING triggertransitions + | + ; + +triggertransitions + : triggertransition+ + ; + +triggertransition + : transitionoldornew transitionrowortable opt_as transitionrelname + ; + +transitionoldornew + : NEW + | OLD + ; + +transitionrowortable + : TABLE + | ROW + ; + +transitionrelname + : colid + ; + +triggerforspec + : FOR triggerforopteach triggerfortype + | + ; + +triggerforopteach + : EACH + | + ; + +triggerfortype + : ROW + | STATEMENT + ; + +triggerwhen + : WHEN OPEN_PAREN a_expr CLOSE_PAREN + | + ; + +function_or_procedure + : FUNCTION + | PROCEDURE + ; + +triggerfuncargs + : (triggerfuncarg |) (COMMA triggerfuncarg)* + ; + +triggerfuncarg + : iconst + | fconst + | sconst + | collabel + ; + +optconstrfromtable + : FROM qualified_name + | + ; + +constraintattributespec + : constraintattributeElem* + ; + +constraintattributeElem + : NOT DEFERRABLE + | DEFERRABLE + | INITIALLY IMMEDIATE + | INITIALLY DEFERRED + | NOT VALID + | NO INHERIT + ; + +createeventtrigstmt + : CREATE EVENT TRIGGER name ON collabel EXECUTE function_or_procedure func_name OPEN_PAREN CLOSE_PAREN + | CREATE EVENT TRIGGER name ON collabel WHEN event_trigger_when_list EXECUTE function_or_procedure func_name OPEN_PAREN CLOSE_PAREN + ; + +event_trigger_when_list + : event_trigger_when_item (AND event_trigger_when_item)* + ; + +event_trigger_when_item + : colid IN_P OPEN_PAREN event_trigger_value_list CLOSE_PAREN + ; + +event_trigger_value_list + : sconst (COMMA sconst)* + ; + +altereventtrigstmt + : ALTER EVENT TRIGGER name enable_trigger + ; + +enable_trigger + : ENABLE_P + | ENABLE_P REPLICA + | ENABLE_P ALWAYS + | DISABLE_P + ; + +createassertionstmt + : CREATE ASSERTION any_name CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec + ; + +definestmt + : CREATE opt_or_replace AGGREGATE func_name aggr_args definition + | CREATE opt_or_replace AGGREGATE func_name old_aggr_definition + | CREATE OPERATOR any_operator definition + | CREATE TYPE_P any_name definition + | CREATE TYPE_P any_name + | CREATE TYPE_P any_name AS OPEN_PAREN opttablefuncelementlist CLOSE_PAREN + | CREATE TYPE_P any_name AS ENUM_P OPEN_PAREN opt_enum_val_list CLOSE_PAREN + | CREATE TYPE_P any_name AS RANGE definition + | CREATE TEXT_P SEARCH PARSER any_name definition + | CREATE TEXT_P SEARCH DICTIONARY any_name definition + | CREATE TEXT_P SEARCH TEMPLATE any_name definition + | CREATE TEXT_P SEARCH CONFIGURATION any_name definition + | CREATE COLLATION any_name definition + | CREATE COLLATION IF_P NOT EXISTS any_name definition + | CREATE COLLATION any_name FROM any_name + | CREATE COLLATION IF_P NOT EXISTS any_name FROM any_name + ; + +definition + : OPEN_PAREN def_list CLOSE_PAREN + ; + +def_list + : def_elem (COMMA def_elem)* + ; + +def_elem + : collabel (EQUAL def_arg)? + ; + +def_arg + : func_type + | reserved_keyword + | qual_all_op + | numericonly + | sconst + | NONE + ; + +old_aggr_definition + : OPEN_PAREN old_aggr_list CLOSE_PAREN + ; + +old_aggr_list + : old_aggr_elem (COMMA old_aggr_elem)* + ; + +old_aggr_elem + : identifier EQUAL def_arg + ; + +opt_enum_val_list + : enum_val_list + | + ; + +enum_val_list + : sconst (COMMA sconst)* + ; + +alterenumstmt + : ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists sconst + | ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists sconst BEFORE sconst + | ALTER TYPE_P any_name ADD_P VALUE_P opt_if_not_exists sconst AFTER sconst + | ALTER TYPE_P any_name RENAME VALUE_P sconst TO sconst + ; + +opt_if_not_exists + : IF_P NOT EXISTS + | + ; + +createopclassstmt + : CREATE OPERATOR CLASS any_name opt_default FOR TYPE_P typename USING name opt_opfamily AS opclass_item_list + ; + +opclass_item_list + : opclass_item (COMMA opclass_item)* + ; + +opclass_item + : OPERATOR iconst any_operator opclass_purpose opt_recheck + | OPERATOR iconst operator_with_argtypes opclass_purpose opt_recheck + | FUNCTION iconst function_with_argtypes + | FUNCTION iconst OPEN_PAREN type_list CLOSE_PAREN function_with_argtypes + | STORAGE typename + ; + +opt_default + : DEFAULT + | + ; + +opt_opfamily + : FAMILY any_name + | + ; + +opclass_purpose + : FOR SEARCH + | FOR ORDER BY any_name + | + ; + +opt_recheck + : RECHECK + | + ; + +createopfamilystmt + : CREATE OPERATOR FAMILY any_name USING name + ; + +alteropfamilystmt + : ALTER OPERATOR FAMILY any_name USING name ADD_P opclass_item_list + | ALTER OPERATOR FAMILY any_name USING name DROP opclass_drop_list + ; + +opclass_drop_list + : opclass_drop (COMMA opclass_drop)* + ; + +opclass_drop + : OPERATOR iconst OPEN_PAREN type_list CLOSE_PAREN + | FUNCTION iconst OPEN_PAREN type_list CLOSE_PAREN + ; + +dropopclassstmt + : DROP OPERATOR CLASS any_name USING name opt_drop_behavior + | DROP OPERATOR CLASS IF_P EXISTS any_name USING name opt_drop_behavior + ; + +dropopfamilystmt + : DROP OPERATOR FAMILY any_name USING name opt_drop_behavior + | DROP OPERATOR FAMILY IF_P EXISTS any_name USING name opt_drop_behavior + ; + +dropownedstmt + : DROP OWNED BY role_list opt_drop_behavior + ; + +reassignownedstmt + : REASSIGN OWNED BY role_list TO rolespec + ; + +dropstmt + : DROP object_type_any_name IF_P EXISTS any_name_list opt_drop_behavior + | DROP object_type_any_name any_name_list opt_drop_behavior + | DROP drop_type_name IF_P EXISTS name_list opt_drop_behavior + | DROP drop_type_name name_list opt_drop_behavior + | DROP object_type_name_on_any_name name ON any_name opt_drop_behavior + | DROP object_type_name_on_any_name IF_P EXISTS name ON any_name opt_drop_behavior + | DROP TYPE_P type_name_list opt_drop_behavior + | DROP TYPE_P IF_P EXISTS type_name_list opt_drop_behavior + | DROP DOMAIN_P type_name_list opt_drop_behavior + | DROP DOMAIN_P IF_P EXISTS type_name_list opt_drop_behavior + | DROP INDEX CONCURRENTLY any_name_list opt_drop_behavior + | DROP INDEX CONCURRENTLY IF_P EXISTS any_name_list opt_drop_behavior + ; + +object_type_any_name + : TABLE + | SEQUENCE + | VIEW + | MATERIALIZED VIEW + | INDEX + | FOREIGN TABLE + | COLLATION + | CONVERSION_P + | STATISTICS + | TEXT_P SEARCH PARSER + | TEXT_P SEARCH DICTIONARY + | TEXT_P SEARCH TEMPLATE + | TEXT_P SEARCH CONFIGURATION + ; + +object_type_name + : drop_type_name + | DATABASE + | ROLE + | SUBSCRIPTION + | TABLESPACE + ; + +drop_type_name + : ACCESS METHOD + | EVENT TRIGGER + | EXTENSION + | FOREIGN DATA_P WRAPPER + | opt_procedural LANGUAGE + | PUBLICATION + | SCHEMA + | SERVER + ; + +object_type_name_on_any_name + : POLICY + | RULE + | TRIGGER + ; + +any_name_list + : any_name (COMMA any_name)* + ; + +any_name + : colid attrs? + ; + +attrs + :(DOT attr_name)+ + ; + +type_name_list + : typename (COMMA typename)* + ; + +truncatestmt + : TRUNCATE opt_table relation_expr_list opt_restart_seqs opt_drop_behavior + ; + +opt_restart_seqs + : CONTINUE_P IDENTITY_P + | RESTART IDENTITY_P + | + ; + +commentstmt + : COMMENT ON object_type_any_name any_name IS comment_text + | COMMENT ON COLUMN any_name IS comment_text + | COMMENT ON object_type_name name IS comment_text + | COMMENT ON TYPE_P typename IS comment_text + | COMMENT ON DOMAIN_P typename IS comment_text + | COMMENT ON AGGREGATE aggregate_with_argtypes IS comment_text + | COMMENT ON FUNCTION function_with_argtypes IS comment_text + | COMMENT ON OPERATOR operator_with_argtypes IS comment_text + | COMMENT ON CONSTRAINT name ON any_name IS comment_text + | COMMENT ON CONSTRAINT name ON DOMAIN_P any_name IS comment_text + | COMMENT ON object_type_name_on_any_name name ON any_name IS comment_text + | COMMENT ON PROCEDURE function_with_argtypes IS comment_text + | COMMENT ON ROUTINE function_with_argtypes IS comment_text + | COMMENT ON TRANSFORM FOR typename LANGUAGE name IS comment_text + | COMMENT ON OPERATOR CLASS any_name USING name IS comment_text + | COMMENT ON OPERATOR FAMILY any_name USING name IS comment_text + | COMMENT ON LARGE_P OBJECT_P numericonly IS comment_text + | COMMENT ON CAST OPEN_PAREN typename AS typename CLOSE_PAREN IS comment_text + ; + +comment_text + : sconst + | NULL_P + ; + +seclabelstmt + : SECURITY LABEL opt_provider ON object_type_any_name any_name IS security_label + | SECURITY LABEL opt_provider ON COLUMN any_name IS security_label + | SECURITY LABEL opt_provider ON object_type_name name IS security_label + | SECURITY LABEL opt_provider ON TYPE_P typename IS security_label + | SECURITY LABEL opt_provider ON DOMAIN_P typename IS security_label + | SECURITY LABEL opt_provider ON AGGREGATE aggregate_with_argtypes IS security_label + | SECURITY LABEL opt_provider ON FUNCTION function_with_argtypes IS security_label + | SECURITY LABEL opt_provider ON LARGE_P OBJECT_P numericonly IS security_label + | SECURITY LABEL opt_provider ON PROCEDURE function_with_argtypes IS security_label + | SECURITY LABEL opt_provider ON ROUTINE function_with_argtypes IS security_label + ; + +opt_provider + : FOR nonreservedword_or_sconst + | + ; + +security_label + : sconst + | NULL_P + ; + +fetchstmt + : FETCH fetch_args + | MOVE fetch_args + ; + +fetch_args + : cursor_name + | from_in cursor_name + | NEXT opt_from_in cursor_name + | PRIOR opt_from_in cursor_name + | FIRST_P opt_from_in cursor_name + | LAST_P opt_from_in cursor_name + | ABSOLUTE_P signediconst opt_from_in cursor_name + | RELATIVE_P signediconst opt_from_in cursor_name + | signediconst opt_from_in cursor_name + | ALL opt_from_in cursor_name + | FORWARD opt_from_in cursor_name + | FORWARD signediconst opt_from_in cursor_name + | FORWARD ALL opt_from_in cursor_name + | BACKWARD opt_from_in cursor_name + | BACKWARD signediconst opt_from_in cursor_name + | BACKWARD ALL opt_from_in cursor_name + ; + +from_in + : FROM + | IN_P + ; + +opt_from_in + : from_in + | + ; + +grantstmt + : GRANT privileges ON privilege_target TO grantee_list opt_grant_grant_option + ; + +revokestmt + : REVOKE privileges ON privilege_target FROM grantee_list opt_drop_behavior + | REVOKE GRANT OPTION FOR privileges ON privilege_target FROM grantee_list opt_drop_behavior + ; + +privileges + : privilege_list + | ALL + | ALL PRIVILEGES + | ALL OPEN_PAREN columnlist CLOSE_PAREN + | ALL PRIVILEGES OPEN_PAREN columnlist CLOSE_PAREN + ; + +privilege_list + : privilege (COMMA privilege)* + ; + +privilege + : SELECT opt_column_list + | REFERENCES opt_column_list + | CREATE opt_column_list + | colid opt_column_list + ; + +privilege_target + : qualified_name_list + | TABLE qualified_name_list + | SEQUENCE qualified_name_list + | FOREIGN DATA_P WRAPPER name_list + | FOREIGN SERVER name_list + | FUNCTION function_with_argtypes_list + | PROCEDURE function_with_argtypes_list + | ROUTINE function_with_argtypes_list + | DATABASE name_list + | DOMAIN_P any_name_list + | LANGUAGE name_list + | LARGE_P OBJECT_P numericonly_list + | SCHEMA name_list + | TABLESPACE name_list + | TYPE_P any_name_list + | ALL TABLES IN_P SCHEMA name_list + | ALL SEQUENCES IN_P SCHEMA name_list + | ALL FUNCTIONS IN_P SCHEMA name_list + | ALL PROCEDURES IN_P SCHEMA name_list + | ALL ROUTINES IN_P SCHEMA name_list + ; + +grantee_list + : grantee (COMMA grantee)* + ; + +grantee + : rolespec + | GROUP_P rolespec + ; + +opt_grant_grant_option + : WITH GRANT OPTION + | + ; + +grantrolestmt + : GRANT privilege_list TO role_list opt_grant_admin_option opt_granted_by + ; + +revokerolestmt + : REVOKE privilege_list FROM role_list opt_granted_by opt_drop_behavior + | REVOKE ADMIN OPTION FOR privilege_list FROM role_list opt_granted_by opt_drop_behavior + ; + +opt_grant_admin_option + : WITH ADMIN OPTION + | + ; + +opt_granted_by + : GRANTED BY rolespec + | + ; + +alterdefaultprivilegesstmt + : ALTER DEFAULT PRIVILEGES defacloptionlist defaclaction + ; + +defacloptionlist + : defacloption* + ; + +defacloption + : IN_P SCHEMA name_list + | FOR ROLE role_list + | FOR USER role_list + ; + +defaclaction + : GRANT privileges ON defacl_privilege_target TO grantee_list opt_grant_grant_option + | REVOKE privileges ON defacl_privilege_target FROM grantee_list opt_drop_behavior + | REVOKE GRANT OPTION FOR privileges ON defacl_privilege_target FROM grantee_list opt_drop_behavior + ; + +defacl_privilege_target + : TABLES + | FUNCTIONS + | ROUTINES + | SEQUENCES + | TYPES_P + | SCHEMAS + ; + //create index + +indexstmt + : CREATE opt_unique INDEX opt_concurrently opt_index_name ON relation_expr access_method_clause OPEN_PAREN index_params CLOSE_PAREN opt_include opt_reloptions opttablespace where_clause + | CREATE opt_unique INDEX opt_concurrently IF_P NOT EXISTS name ON relation_expr access_method_clause OPEN_PAREN index_params CLOSE_PAREN opt_include opt_reloptions opttablespace where_clause + ; + +opt_unique + : UNIQUE + | + ; + +opt_concurrently + : CONCURRENTLY + | + ; + +opt_index_name + : name + | + ; + +access_method_clause + : USING name + | + ; + +index_params + : index_elem (COMMA index_elem)* + ; + +index_elem_options + : opt_collate opt_class opt_asc_desc opt_nulls_order + | opt_collate any_name reloptions opt_asc_desc opt_nulls_order + ; + +index_elem + : colid index_elem_options + | func_expr_windowless index_elem_options + | OPEN_PAREN a_expr CLOSE_PAREN index_elem_options + ; + +opt_include + : INCLUDE OPEN_PAREN index_including_params CLOSE_PAREN + | + ; + +index_including_params + : index_elem (COMMA index_elem)* + ; + +opt_collate + : COLLATE any_name + | + ; + +opt_class + : any_name + | + ; + +opt_asc_desc + : ASC + | DESC + | + ; + //TOD NULLS_LA was used + +opt_nulls_order + : NULLS_P FIRST_P + | NULLS_P LAST_P + | + ; + +createfunctionstmt + : CREATE opt_or_replace (FUNCTION | PROCEDURE) func_name func_args_with_defaults + ( + RETURNS (func_return | TABLE OPEN_PAREN table_func_column_list CLOSE_PAREN) + )? + createfunc_opt_list + ; + +opt_or_replace + : OR REPLACE + | + ; + +func_args + : OPEN_PAREN func_args_list? CLOSE_PAREN + ; + +func_args_list + : func_arg (COMMA func_arg)* + ; + +function_with_argtypes_list + : function_with_argtypes (COMMA function_with_argtypes)* + ; + +function_with_argtypes + : func_name func_args + | type_func_name_keyword + | colid indirection? + ; + +func_args_with_defaults + : OPEN_PAREN func_args_with_defaults_list? CLOSE_PAREN + ; + +func_args_with_defaults_list + : func_arg_with_default (COMMA func_arg_with_default)* + ; + +func_arg + : arg_class param_name? func_type + | param_name arg_class? func_type + | func_type + ; + +arg_class + : IN_P OUT_P? + | OUT_P + | INOUT + | VARIADIC + ; + +param_name + : type_function_name + ; + +func_return + : func_type + ; + +func_type + : typename + | type_function_name attrs PERCENT TYPE_P + | SETOF type_function_name attrs PERCENT TYPE_P + ; + +func_arg_with_default + : func_arg ((DEFAULT | EQUAL) a_expr)? + ; + +aggr_arg + : func_arg + ; + +aggr_args + : OPEN_PAREN (STAR | aggr_args_list | ORDER BY aggr_args_list | aggr_args_list ORDER BY aggr_args_list) CLOSE_PAREN + ; + +aggr_args_list + : aggr_arg (COMMA aggr_arg)* + ; + +aggregate_with_argtypes + : func_name aggr_args + ; + +aggregate_with_argtypes_list + : aggregate_with_argtypes (COMMA aggregate_with_argtypes)* + ; + +createfunc_opt_list + : createfunc_opt_item+ + { + ParseRoutineBody(_localctx); + } + // | createfunc_opt_list createfunc_opt_item + + ; + +common_func_opt_item + : CALLED ON NULL_P INPUT_P + | RETURNS NULL_P ON NULL_P INPUT_P + | STRICT_P + | IMMUTABLE + | STABLE + | VOLATILE + | EXTERNAL SECURITY DEFINER + | EXTERNAL SECURITY INVOKER + | SECURITY DEFINER + | SECURITY INVOKER + | LEAKPROOF + | NOT LEAKPROOF + | COST numericonly + | ROWS numericonly + | SUPPORT any_name + | functionsetresetclause + | PARALLEL colid + ; + +createfunc_opt_item + : AS func_as + | LANGUAGE nonreservedword_or_sconst + | TRANSFORM transform_type_list + | WINDOW + | common_func_opt_item + ; + //https://www.postgresql.org/docs/9.1/sql-createfunction.html + + // | AS 'definition' + + // | AS 'obj_file', 'link_symbol' + +func_as locals[ParserRuleContext Definition] + : + /* |AS 'definition'*/ + def = sconst + /*| AS 'obj_file', 'link_symbol'*/ + | sconst COMMA sconst + ; + +transform_type_list + :FOR TYPE_P typename (COMMA FOR TYPE_P typename)* + ; + +opt_definition + : WITH definition + | + ; + +table_func_column + : param_name func_type + ; + +table_func_column_list + : table_func_column (COMMA table_func_column)* + ; + +alterfunctionstmt + : ALTER (FUNCTION | PROCEDURE | ROUTINE) function_with_argtypes alterfunc_opt_list opt_restrict + ; + +alterfunc_opt_list + : common_func_opt_item+ + ; + +opt_restrict + : RESTRICT + | + ; + +removefuncstmt + : DROP FUNCTION function_with_argtypes_list opt_drop_behavior + | DROP FUNCTION IF_P EXISTS function_with_argtypes_list opt_drop_behavior + | DROP PROCEDURE function_with_argtypes_list opt_drop_behavior + | DROP PROCEDURE IF_P EXISTS function_with_argtypes_list opt_drop_behavior + | DROP ROUTINE function_with_argtypes_list opt_drop_behavior + | DROP ROUTINE IF_P EXISTS function_with_argtypes_list opt_drop_behavior + ; + +removeaggrstmt + : DROP AGGREGATE aggregate_with_argtypes_list opt_drop_behavior + | DROP AGGREGATE IF_P EXISTS aggregate_with_argtypes_list opt_drop_behavior + ; + +removeoperstmt + : DROP OPERATOR operator_with_argtypes_list opt_drop_behavior + | DROP OPERATOR IF_P EXISTS operator_with_argtypes_list opt_drop_behavior + ; + +oper_argtypes + : OPEN_PAREN typename CLOSE_PAREN + | OPEN_PAREN typename COMMA typename CLOSE_PAREN + | OPEN_PAREN NONE COMMA typename CLOSE_PAREN + | OPEN_PAREN typename COMMA NONE CLOSE_PAREN + ; + +any_operator + : (colid DOT)* all_op + ; + +operator_with_argtypes_list + : operator_with_argtypes (COMMA operator_with_argtypes)* + ; + +operator_with_argtypes + : any_operator oper_argtypes + ; + +dostmt + : DO dostmt_opt_list + ; + +dostmt_opt_list + : dostmt_opt_item+ + ; + +dostmt_opt_item + : sconst + | LANGUAGE nonreservedword_or_sconst + ; + +createcaststmt + : CREATE CAST OPEN_PAREN typename AS typename CLOSE_PAREN WITH FUNCTION function_with_argtypes cast_context + | CREATE CAST OPEN_PAREN typename AS typename CLOSE_PAREN WITHOUT FUNCTION cast_context + | CREATE CAST OPEN_PAREN typename AS typename CLOSE_PAREN WITH INOUT cast_context + ; + +cast_context + : AS IMPLICIT_P + | AS ASSIGNMENT + | + ; + +dropcaststmt + : DROP CAST opt_if_exists OPEN_PAREN typename AS typename CLOSE_PAREN opt_drop_behavior + ; + +opt_if_exists + : IF_P EXISTS + | + ; + +createtransformstmt + : CREATE opt_or_replace TRANSFORM FOR typename LANGUAGE name OPEN_PAREN transform_element_list CLOSE_PAREN + ; + +transform_element_list + : FROM SQL_P WITH FUNCTION function_with_argtypes COMMA TO SQL_P WITH FUNCTION function_with_argtypes + | TO SQL_P WITH FUNCTION function_with_argtypes COMMA FROM SQL_P WITH FUNCTION function_with_argtypes + | FROM SQL_P WITH FUNCTION function_with_argtypes + | TO SQL_P WITH FUNCTION function_with_argtypes + ; + +droptransformstmt + : DROP TRANSFORM opt_if_exists FOR typename LANGUAGE name opt_drop_behavior + ; + +reindexstmt + : REINDEX reindex_target_type opt_concurrently qualified_name + | REINDEX reindex_target_multitable opt_concurrently name + | REINDEX OPEN_PAREN reindex_option_list CLOSE_PAREN reindex_target_type opt_concurrently qualified_name + | REINDEX OPEN_PAREN reindex_option_list CLOSE_PAREN reindex_target_multitable opt_concurrently name + ; + +reindex_target_type + : INDEX + | TABLE + ; + +reindex_target_multitable + : SCHEMA + | SYSTEM_P + | DATABASE + ; + +reindex_option_list + : reindex_option_elem (COMMA reindex_option_elem)* + ; + +reindex_option_elem + : VERBOSE + ; + +altertblspcstmt + : ALTER TABLESPACE name SET reloptions + | ALTER TABLESPACE name RESET reloptions + ; + +renamestmt + : ALTER AGGREGATE aggregate_with_argtypes RENAME TO name + | ALTER COLLATION any_name RENAME TO name + | ALTER CONVERSION_P any_name RENAME TO name + | ALTER DATABASE name RENAME TO name + | ALTER DOMAIN_P any_name RENAME TO name + | ALTER DOMAIN_P any_name RENAME CONSTRAINT name TO name + | ALTER FOREIGN DATA_P WRAPPER name RENAME TO name + | ALTER FUNCTION function_with_argtypes RENAME TO name + | ALTER GROUP_P roleid RENAME TO roleid + | ALTER opt_procedural LANGUAGE name RENAME TO name + | ALTER OPERATOR CLASS any_name USING name RENAME TO name + | ALTER OPERATOR FAMILY any_name USING name RENAME TO name + | ALTER POLICY name ON qualified_name RENAME TO name + | ALTER POLICY IF_P EXISTS name ON qualified_name RENAME TO name + | ALTER PROCEDURE function_with_argtypes RENAME TO name + | ALTER PUBLICATION name RENAME TO name + | ALTER ROUTINE function_with_argtypes RENAME TO name + | ALTER SCHEMA name RENAME TO name + | ALTER SERVER name RENAME TO name + | ALTER SUBSCRIPTION name RENAME TO name + | ALTER TABLE relation_expr RENAME TO name + | ALTER TABLE IF_P EXISTS relation_expr RENAME TO name + | ALTER SEQUENCE qualified_name RENAME TO name + | ALTER SEQUENCE IF_P EXISTS qualified_name RENAME TO name + | ALTER VIEW qualified_name RENAME TO name + | ALTER VIEW IF_P EXISTS qualified_name RENAME TO name + | ALTER MATERIALIZED VIEW qualified_name RENAME TO name + | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME TO name + | ALTER INDEX qualified_name RENAME TO name + | ALTER INDEX IF_P EXISTS qualified_name RENAME TO name + | ALTER FOREIGN TABLE relation_expr RENAME TO name + | ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME TO name + | ALTER TABLE relation_expr RENAME opt_column name TO name + | ALTER TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name + | ALTER VIEW qualified_name RENAME opt_column name TO name + | ALTER VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name + | ALTER MATERIALIZED VIEW qualified_name RENAME opt_column name TO name + | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name RENAME opt_column name TO name + | ALTER TABLE relation_expr RENAME CONSTRAINT name TO name + | ALTER TABLE IF_P EXISTS relation_expr RENAME CONSTRAINT name TO name + | ALTER FOREIGN TABLE relation_expr RENAME opt_column name TO name + | ALTER FOREIGN TABLE IF_P EXISTS relation_expr RENAME opt_column name TO name + | ALTER RULE name ON qualified_name RENAME TO name + | ALTER TRIGGER name ON qualified_name RENAME TO name + | ALTER EVENT TRIGGER name RENAME TO name + | ALTER ROLE roleid RENAME TO roleid + | ALTER USER roleid RENAME TO roleid + | ALTER TABLESPACE name RENAME TO name + | ALTER STATISTICS any_name RENAME TO name + | ALTER TEXT_P SEARCH PARSER any_name RENAME TO name + | ALTER TEXT_P SEARCH DICTIONARY any_name RENAME TO name + | ALTER TEXT_P SEARCH TEMPLATE any_name RENAME TO name + | ALTER TEXT_P SEARCH CONFIGURATION any_name RENAME TO name + | ALTER TYPE_P any_name RENAME TO name + | ALTER TYPE_P any_name RENAME ATTRIBUTE name TO name opt_drop_behavior + ; + +opt_column + : COLUMN + | + ; + +opt_set_data + : SET DATA_P + | + ; + +alterobjectdependsstmt + : ALTER FUNCTION function_with_argtypes opt_no DEPENDS ON EXTENSION name + | ALTER PROCEDURE function_with_argtypes opt_no DEPENDS ON EXTENSION name + | ALTER ROUTINE function_with_argtypes opt_no DEPENDS ON EXTENSION name + | ALTER TRIGGER name ON qualified_name opt_no DEPENDS ON EXTENSION name + | ALTER MATERIALIZED VIEW qualified_name opt_no DEPENDS ON EXTENSION name + | ALTER INDEX qualified_name opt_no DEPENDS ON EXTENSION name + ; + +opt_no + : NO + | + ; + +alterobjectschemastmt + : ALTER AGGREGATE aggregate_with_argtypes SET SCHEMA name + | ALTER COLLATION any_name SET SCHEMA name + | ALTER CONVERSION_P any_name SET SCHEMA name + | ALTER DOMAIN_P any_name SET SCHEMA name + | ALTER EXTENSION name SET SCHEMA name + | ALTER FUNCTION function_with_argtypes SET SCHEMA name + | ALTER OPERATOR operator_with_argtypes SET SCHEMA name + | ALTER OPERATOR CLASS any_name USING name SET SCHEMA name + | ALTER OPERATOR FAMILY any_name USING name SET SCHEMA name + | ALTER PROCEDURE function_with_argtypes SET SCHEMA name + | ALTER ROUTINE function_with_argtypes SET SCHEMA name + | ALTER TABLE relation_expr SET SCHEMA name + | ALTER TABLE IF_P EXISTS relation_expr SET SCHEMA name + | ALTER STATISTICS any_name SET SCHEMA name + | ALTER TEXT_P SEARCH PARSER any_name SET SCHEMA name + | ALTER TEXT_P SEARCH DICTIONARY any_name SET SCHEMA name + | ALTER TEXT_P SEARCH TEMPLATE any_name SET SCHEMA name + | ALTER TEXT_P SEARCH CONFIGURATION any_name SET SCHEMA name + | ALTER SEQUENCE qualified_name SET SCHEMA name + | ALTER SEQUENCE IF_P EXISTS qualified_name SET SCHEMA name + | ALTER VIEW qualified_name SET SCHEMA name + | ALTER VIEW IF_P EXISTS qualified_name SET SCHEMA name + | ALTER MATERIALIZED VIEW qualified_name SET SCHEMA name + | ALTER MATERIALIZED VIEW IF_P EXISTS qualified_name SET SCHEMA name + | ALTER FOREIGN TABLE relation_expr SET SCHEMA name + | ALTER FOREIGN TABLE IF_P EXISTS relation_expr SET SCHEMA name + | ALTER TYPE_P any_name SET SCHEMA name + ; + +alteroperatorstmt + : ALTER OPERATOR operator_with_argtypes SET OPEN_PAREN operator_def_list CLOSE_PAREN + ; + +operator_def_list + : operator_def_elem (COMMA operator_def_elem)* + ; + +operator_def_elem + : collabel EQUAL NONE + | collabel EQUAL operator_def_arg + ; + +operator_def_arg + : func_type + | reserved_keyword + | qual_all_op + | numericonly + | sconst + ; + +altertypestmt + : ALTER TYPE_P any_name SET OPEN_PAREN operator_def_list CLOSE_PAREN + ; + +alterownerstmt + : ALTER AGGREGATE aggregate_with_argtypes OWNER TO rolespec + | ALTER COLLATION any_name OWNER TO rolespec + | ALTER CONVERSION_P any_name OWNER TO rolespec + | ALTER DATABASE name OWNER TO rolespec + | ALTER DOMAIN_P any_name OWNER TO rolespec + | ALTER FUNCTION function_with_argtypes OWNER TO rolespec + | ALTER opt_procedural LANGUAGE name OWNER TO rolespec + | ALTER LARGE_P OBJECT_P numericonly OWNER TO rolespec + | ALTER OPERATOR operator_with_argtypes OWNER TO rolespec + | ALTER OPERATOR CLASS any_name USING name OWNER TO rolespec + | ALTER OPERATOR FAMILY any_name USING name OWNER TO rolespec + | ALTER PROCEDURE function_with_argtypes OWNER TO rolespec + | ALTER ROUTINE function_with_argtypes OWNER TO rolespec + | ALTER SCHEMA name OWNER TO rolespec + | ALTER TYPE_P any_name OWNER TO rolespec + | ALTER TABLESPACE name OWNER TO rolespec + | ALTER STATISTICS any_name OWNER TO rolespec + | ALTER TEXT_P SEARCH DICTIONARY any_name OWNER TO rolespec + | ALTER TEXT_P SEARCH CONFIGURATION any_name OWNER TO rolespec + | ALTER FOREIGN DATA_P WRAPPER name OWNER TO rolespec + | ALTER SERVER name OWNER TO rolespec + | ALTER EVENT TRIGGER name OWNER TO rolespec + | ALTER PUBLICATION name OWNER TO rolespec + | ALTER SUBSCRIPTION name OWNER TO rolespec + ; + +createpublicationstmt + : CREATE PUBLICATION name opt_publication_for_tables opt_definition + ; + +opt_publication_for_tables + : publication_for_tables + | + ; + +publication_for_tables + : FOR TABLE relation_expr_list + | FOR ALL TABLES + ; + +alterpublicationstmt + : ALTER PUBLICATION name SET definition + | ALTER PUBLICATION name ADD_P TABLE relation_expr_list + | ALTER PUBLICATION name SET TABLE relation_expr_list + | ALTER PUBLICATION name DROP TABLE relation_expr_list + ; + +createsubscriptionstmt + : CREATE SUBSCRIPTION name CONNECTION sconst PUBLICATION publication_name_list opt_definition + ; + +publication_name_list + : publication_name_item (COMMA publication_name_item)* + ; + +publication_name_item + : collabel + ; + +altersubscriptionstmt + : ALTER SUBSCRIPTION name SET definition + | ALTER SUBSCRIPTION name CONNECTION sconst + | ALTER SUBSCRIPTION name REFRESH PUBLICATION opt_definition + | ALTER SUBSCRIPTION name SET PUBLICATION publication_name_list opt_definition + | ALTER SUBSCRIPTION name ENABLE_P + | ALTER SUBSCRIPTION name DISABLE_P + ; + +dropsubscriptionstmt + : DROP SUBSCRIPTION name opt_drop_behavior + | DROP SUBSCRIPTION IF_P EXISTS name opt_drop_behavior + ; + +rulestmt + : CREATE opt_or_replace RULE name AS ON event TO qualified_name where_clause DO opt_instead ruleactionlist + ; + +ruleactionlist + : NOTHING + | ruleactionstmt + | OPEN_PAREN ruleactionmulti CLOSE_PAREN + ; + +ruleactionmulti + : ruleactionstmtOrEmpty (SEMI ruleactionstmtOrEmpty)* + ; + +ruleactionstmt + : selectstmt + | insertstmt + | updatestmt + | deletestmt + | notifystmt + ; + +ruleactionstmtOrEmpty + : ruleactionstmt + | + ; + +event + : SELECT + | UPDATE + | DELETE_P + | INSERT + ; + +opt_instead + : INSTEAD + | ALSO + | + ; + +notifystmt + : NOTIFY colid notify_payload + ; + +notify_payload + : COMMA sconst + | + ; + +listenstmt + : LISTEN colid + ; + +unlistenstmt + : UNLISTEN colid + | UNLISTEN STAR + ; + +transactionstmt + : ABORT_P opt_transaction opt_transaction_chain + | BEGIN_P opt_transaction transaction_mode_list_or_empty + | START TRANSACTION transaction_mode_list_or_empty + | COMMIT opt_transaction opt_transaction_chain + | END_P opt_transaction opt_transaction_chain + | ROLLBACK opt_transaction opt_transaction_chain + | SAVEPOINT colid + | RELEASE SAVEPOINT colid + | RELEASE colid + | ROLLBACK opt_transaction TO SAVEPOINT colid + | ROLLBACK opt_transaction TO colid + | PREPARE TRANSACTION sconst + | COMMIT PREPARED sconst + | ROLLBACK PREPARED sconst + ; + +opt_transaction + : WORK + | TRANSACTION + | + ; + +transaction_mode_item + : ISOLATION LEVEL iso_level + | READ ONLY + | READ WRITE + | DEFERRABLE + | NOT DEFERRABLE + ; + +transaction_mode_list + : transaction_mode_item (COMMA? transaction_mode_item)* + ; + +transaction_mode_list_or_empty + : transaction_mode_list + | + ; + +opt_transaction_chain + : AND NO? CHAIN + | + ; + +viewstmt + : CREATE (OR REPLACE)? opttemp + ( + VIEW qualified_name opt_column_list opt_reloptions + | RECURSIVE VIEW qualified_name OPEN_PAREN columnlist CLOSE_PAREN opt_reloptions + ) + AS selectstmt opt_check_option + ; + +opt_check_option + : WITH (CASCADED | LOCAL)? CHECK OPTION + | + ; + +loadstmt + : LOAD file_name + ; + +createdbstmt + : CREATE DATABASE name opt_with createdb_opt_list + ; + +createdb_opt_list + : createdb_opt_items + | + ; + +createdb_opt_items + : createdb_opt_item+ + ; + +createdb_opt_item + : createdb_opt_name opt_equal (signediconst | opt_boolean_or_string | DEFAULT) + ; + +createdb_opt_name + : identifier + | CONNECTION LIMIT + | ENCODING + | LOCATION + | OWNER + | TABLESPACE + | TEMPLATE + ; + +opt_equal + : EQUAL + | + ; + +alterdatabasestmt + : ALTER DATABASE name (WITH createdb_opt_list | createdb_opt_list | SET TABLESPACE name) + ; + +alterdatabasesetstmt + : ALTER DATABASE name setresetclause + ; + +dropdbstmt + : DROP DATABASE (IF_P EXISTS)? name (opt_with OPEN_PAREN drop_option_list CLOSE_PAREN)? + ; + +drop_option_list + : drop_option (COMMA drop_option)* + ; + +drop_option + : FORCE + ; + +altercollationstmt + : ALTER COLLATION any_name REFRESH VERSION_P + ; + +altersystemstmt + : ALTER SYSTEM_P (SET | RESET) generic_set + ; + +createdomainstmt + : CREATE DOMAIN_P any_name opt_as typename colquallist + ; + +alterdomainstmt + : ALTER DOMAIN_P any_name (alter_column_default | DROP NOT NULL_P | SET NOT NULL_P | ADD_P tableconstraint | DROP CONSTRAINT (IF_P EXISTS)? name opt_drop_behavior | VALIDATE CONSTRAINT name) + ; + +opt_as + : AS + | + ; + +altertsdictionarystmt + : ALTER TEXT_P SEARCH DICTIONARY any_name definition + ; + +altertsconfigurationstmt + : ALTER TEXT_P SEARCH CONFIGURATION any_name ADD_P MAPPING FOR name_list any_with any_name_list + | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list any_with any_name_list + | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING REPLACE any_name any_with any_name + | ALTER TEXT_P SEARCH CONFIGURATION any_name ALTER MAPPING FOR name_list REPLACE any_name any_with any_name + | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING FOR name_list + | ALTER TEXT_P SEARCH CONFIGURATION any_name DROP MAPPING IF_P EXISTS FOR name_list + ; + +any_with + : WITH + //TODO + + // | WITH_LA + + ; + +createconversionstmt + : CREATE opt_default CONVERSION_P any_name FOR sconst TO sconst FROM any_name + ; + +clusterstmt + : CLUSTER opt_verbose qualified_name cluster_index_specification + | CLUSTER opt_verbose + | CLUSTER opt_verbose name ON qualified_name + ; + +cluster_index_specification + : USING name + | + ; + +vacuumstmt + : VACUUM opt_full opt_freeze opt_verbose opt_analyze opt_vacuum_relation_list + | VACUUM OPEN_PAREN vac_analyze_option_list CLOSE_PAREN opt_vacuum_relation_list + ; + +analyzestmt + : analyze_keyword opt_verbose opt_vacuum_relation_list + | analyze_keyword OPEN_PAREN vac_analyze_option_list CLOSE_PAREN opt_vacuum_relation_list + ; + +vac_analyze_option_list + : vac_analyze_option_elem (COMMA vac_analyze_option_elem)* + ; + +analyze_keyword + : ANALYZE + | ANALYSE + ; + +vac_analyze_option_elem + : vac_analyze_option_name vac_analyze_option_arg + ; + +vac_analyze_option_name + : nonreservedword + | analyze_keyword + ; + +vac_analyze_option_arg + : opt_boolean_or_string + | numericonly + | + ; + +opt_analyze + : analyze_keyword + | + ; + +opt_verbose + : VERBOSE + | + ; + +opt_full + : FULL + | + ; + +opt_freeze + : FREEZE + | + ; + +opt_name_list + : OPEN_PAREN name_list CLOSE_PAREN + | + ; + +vacuum_relation + : qualified_name opt_name_list + ; + +vacuum_relation_list + : vacuum_relation (COMMA vacuum_relation)* + ; + +opt_vacuum_relation_list + : vacuum_relation_list + | + ; + +explainstmt + : EXPLAIN explainablestmt + | EXPLAIN analyze_keyword opt_verbose explainablestmt + | EXPLAIN VERBOSE explainablestmt + | EXPLAIN OPEN_PAREN explain_option_list CLOSE_PAREN explainablestmt + ; + +explainablestmt + : selectstmt + | insertstmt + | updatestmt + | deletestmt + | declarecursorstmt + | createasstmt + | creatematviewstmt + | refreshmatviewstmt + | executestmt + ; + +explain_option_list + : explain_option_elem (COMMA explain_option_elem)* + ; + +explain_option_elem + : explain_option_name explain_option_arg + ; + +explain_option_name + : nonreservedword + | analyze_keyword + ; + +explain_option_arg + : opt_boolean_or_string + | numericonly + | + ; + +preparestmt + : PREPARE name prep_type_clause AS preparablestmt + ; + +prep_type_clause + : OPEN_PAREN type_list CLOSE_PAREN + | + ; + +preparablestmt + : selectstmt + | insertstmt + | updatestmt + | deletestmt + ; + +executestmt + : EXECUTE name execute_param_clause + | CREATE opttemp TABLE create_as_target AS EXECUTE name execute_param_clause opt_with_data + | CREATE opttemp TABLE IF_P NOT EXISTS create_as_target AS EXECUTE name execute_param_clause opt_with_data + ; + +execute_param_clause + : OPEN_PAREN expr_list CLOSE_PAREN + | + ; + +deallocatestmt + : DEALLOCATE name + | DEALLOCATE PREPARE name + | DEALLOCATE ALL + | DEALLOCATE PREPARE ALL + ; + +insertstmt + : opt_with_clause INSERT INTO insert_target insert_rest opt_on_conflict returning_clause + ; + +insert_target + : qualified_name (AS colid)? + ; + +insert_rest + : selectstmt + | OVERRIDING override_kind VALUE_P selectstmt + | OPEN_PAREN insert_column_list CLOSE_PAREN (OVERRIDING override_kind VALUE_P)? selectstmt + | DEFAULT VALUES + ; + +override_kind + : USER + | SYSTEM_P + ; + +insert_column_list + : insert_column_item (COMMA insert_column_item)* + ; + +insert_column_item + : colid opt_indirection + ; + +opt_on_conflict + : ON CONFLICT opt_conf_expr DO (UPDATE SET set_clause_list where_clause | NOTHING) + | + ; + +opt_conf_expr + : OPEN_PAREN index_params CLOSE_PAREN where_clause + | ON CONSTRAINT name + | + ; + +returning_clause + : RETURNING target_list + | + ; + +deletestmt + : opt_with_clause DELETE_P FROM relation_expr_opt_alias using_clause where_or_current_clause returning_clause + ; + +using_clause + : USING from_list + | + ; + +lockstmt + : LOCK_P opt_table relation_expr_list opt_lock opt_nowait + ; + +opt_lock + : IN_P lock_type MODE + | + ; + +lock_type + : ACCESS (SHARE | EXCLUSIVE) + | ROW (SHARE | EXCLUSIVE) + | SHARE (UPDATE EXCLUSIVE | ROW EXCLUSIVE)? + | EXCLUSIVE + ; + +opt_nowait + : NOWAIT + | + ; + +opt_nowait_or_skip + : NOWAIT + | SKIP_P LOCKED + | + ; + +updatestmt + : opt_with_clause UPDATE relation_expr_opt_alias SET set_clause_list from_clause where_or_current_clause returning_clause + ; + +set_clause_list + : set_clause (COMMA set_clause)* + ; + +set_clause + : set_target EQUAL a_expr + | OPEN_PAREN set_target_list CLOSE_PAREN EQUAL a_expr + ; + +set_target + : colid opt_indirection + ; + +set_target_list + : set_target (COMMA set_target)* + ; + +declarecursorstmt + : DECLARE cursor_name cursor_options CURSOR opt_hold FOR selectstmt + ; + +cursor_name + : name + ; + +cursor_options + : (NO SCROLL | SCROLL | BINARY | INSENSITIVE)* + ; + +opt_hold + : + | WITH HOLD + | WITHOUT HOLD + ; +/* +TODO: why select_with_parens alternative is needed at all? +i guess it because original byson grammar can choose selectstmt(2)->select_with_parens on only OPEN_PARENT/SELECT kewords at the begining of statement; +(select * from tab); +parse can go through selectstmt( )->select_no_parens(1)->select_clause(2)->select_with_parens(1)->select_no_parens(1)->select_clause(1)->simple_select +instead of selectstmt(1)->select_no_parens(1)->select_clause(2)->select_with_parens(1)->select_no_parens(1)->select_clause(1)->simple_select +all standard tests passed on both variants +*/ + + +selectstmt + : select_no_parens + | select_with_parens + ; + +select_with_parens + : OPEN_PAREN select_no_parens CLOSE_PAREN + | OPEN_PAREN select_with_parens CLOSE_PAREN + ; + +select_no_parens + : select_clause opt_sort_clause (for_locking_clause opt_select_limit | select_limit opt_for_locking_clause)? + | with_clause select_clause opt_sort_clause (for_locking_clause opt_select_limit | select_limit opt_for_locking_clause)? + ; + +select_clause + : simple_select + | select_with_parens + ; + +simple_select + : ( SELECT (opt_all_clause into_clause opt_target_list | distinct_clause target_list) + into_clause + from_clause + where_clause + group_clause + having_clause + window_clause + | values_clause + | TABLE relation_expr + | select_with_parens set_operator_with_all_or_distinct (simple_select | select_with_parens) + ) + (set_operator_with_all_or_distinct (simple_select | select_with_parens))* + ; + +set_operator + : UNION # union + | INTERSECT # intersect + | EXCEPT # except + ; + +set_operator_with_all_or_distinct + : set_operator all_or_distinct + ; + +with_clause + : WITH RECURSIVE? cte_list + ; + +cte_list + : common_table_expr (COMMA common_table_expr)* + ; + +common_table_expr + : name opt_name_list AS opt_materialized OPEN_PAREN preparablestmt CLOSE_PAREN + ; + +opt_materialized + : MATERIALIZED + | NOT MATERIALIZED + | + ; + +opt_with_clause + : with_clause + | + ; + +into_clause + : INTO (opt_strict opttempTableName | into_target) + | + ; + +opt_strict + : + | STRICT_P + ; + +opttempTableName + : (LOCAL|GLOBAL)? (TEMPORARY | TEMP) opt_table qualified_name + | UNLOGGED opt_table qualified_name + | TABLE qualified_name + | qualified_name + ; + +opt_table + : TABLE + | + ; + +all_or_distinct + : ALL + | DISTINCT + | + ; + +distinct_clause + : DISTINCT (ON OPEN_PAREN expr_list CLOSE_PAREN)? + ; + +opt_all_clause + : ALL + | + ; + +opt_sort_clause + : sort_clause + | + ; + +sort_clause + : ORDER BY sortby_list + ; + +sortby_list + : sortby (COMMA sortby)* + ; + +sortby + : a_expr (USING qual_all_op | opt_asc_desc) opt_nulls_order + ; + +select_limit + : limit_clause offset_clause? + | offset_clause limit_clause? + ; + +opt_select_limit + : select_limit + | + ; + +limit_clause + : LIMIT select_limit_value (COMMA select_offset_value)? + | FETCH first_or_next (select_fetch_first_value row_or_rows (ONLY | WITH TIES) | row_or_rows (ONLY | WITH TIES)) + ; + +offset_clause + : OFFSET (select_offset_value | select_fetch_first_value row_or_rows) + ; + +select_limit_value + : a_expr + | ALL + ; + +select_offset_value + : a_expr + ; + +select_fetch_first_value + : c_expr + | PLUS i_or_f_const + | MINUS i_or_f_const + ; + +i_or_f_const + : iconst + | fconst + ; + +row_or_rows + : ROW + | ROWS + ; + +first_or_next + : FIRST_P + | NEXT + ; + +group_clause + : GROUP_P BY group_by_list + | + ; + +group_by_list + : group_by_item (COMMA group_by_item)* + ; + +group_by_item + : a_expr + | empty_grouping_set + | cube_clause + | rollup_clause + | grouping_sets_clause + ; + +empty_grouping_set + : OPEN_PAREN CLOSE_PAREN + ; + +rollup_clause + : ROLLUP OPEN_PAREN expr_list CLOSE_PAREN + ; + +cube_clause + : CUBE OPEN_PAREN expr_list CLOSE_PAREN + ; + +grouping_sets_clause + : GROUPING SETS OPEN_PAREN group_by_list CLOSE_PAREN + ; + +having_clause + : HAVING a_expr + | + ; + +for_locking_clause + : for_locking_items + | FOR READ ONLY + ; + +opt_for_locking_clause + : for_locking_clause + | + ; + +for_locking_items + : for_locking_item+ + ; + +for_locking_item + : for_locking_strength locked_rels_list opt_nowait_or_skip + ; + +for_locking_strength + : FOR ((NO KEY)? UPDATE | KEY? SHARE) + ; + +locked_rels_list + : OF qualified_name_list + | + ; + +values_clause + : VALUES OPEN_PAREN expr_list CLOSE_PAREN (COMMA OPEN_PAREN expr_list CLOSE_PAREN)* + ; + +from_clause + : FROM from_list + | + ; + +from_list + : table_ref (COMMA table_ref)* + ; + +table_ref + : (relation_expr opt_alias_clause tablesample_clause? + | func_table func_alias_clause + | xmltable opt_alias_clause + | select_with_parens opt_alias_clause + | LATERAL_P ( + xmltable opt_alias_clause + | func_table func_alias_clause + | select_with_parens opt_alias_clause + ) + | OPEN_PAREN table_ref ( + CROSS JOIN table_ref + | NATURAL join_type? JOIN table_ref + | join_type? JOIN table_ref join_qual + )? CLOSE_PAREN opt_alias_clause + ) + (CROSS JOIN table_ref | NATURAL join_type? JOIN table_ref | join_type? JOIN table_ref join_qual)* + ; + +alias_clause + : AS? colid (OPEN_PAREN name_list CLOSE_PAREN)? + ; + +opt_alias_clause + : alias_clause + | + ; + +func_alias_clause + : alias_clause + | (AS colid? | colid) OPEN_PAREN tablefuncelementlist CLOSE_PAREN + | + ; + +join_type + : (FULL | LEFT | RIGHT | INNER_P) OUTER_P? + ; + +join_qual + : USING OPEN_PAREN name_list CLOSE_PAREN + | ON a_expr + ; + +relation_expr + : qualified_name STAR? + | ONLY (qualified_name | OPEN_PAREN qualified_name CLOSE_PAREN) + ; + +relation_expr_list + : relation_expr (COMMA relation_expr)* + ; + +relation_expr_opt_alias + : relation_expr (AS? colid)? + ; + +tablesample_clause + : TABLESAMPLE func_name OPEN_PAREN expr_list CLOSE_PAREN opt_repeatable_clause + ; + +opt_repeatable_clause + : REPEATABLE OPEN_PAREN a_expr CLOSE_PAREN + | + ; + +func_table + : func_expr_windowless opt_ordinality + | ROWS FROM OPEN_PAREN rowsfrom_list CLOSE_PAREN opt_ordinality + ; + +rowsfrom_item + : func_expr_windowless opt_col_def_list + ; + +rowsfrom_list + : rowsfrom_item (COMMA rowsfrom_item)* + ; + +opt_col_def_list + : AS OPEN_PAREN tablefuncelementlist CLOSE_PAREN + | + ; + //TODO WITH_LA was used + +opt_ordinality + : WITH ORDINALITY + | + ; + +where_clause + : WHERE a_expr + | + ; + +where_or_current_clause + : WHERE (CURRENT_P OF cursor_name | a_expr) + | + ; + +opttablefuncelementlist + : tablefuncelementlist + | + ; + +tablefuncelementlist + : tablefuncelement (COMMA tablefuncelement)* + ; + +tablefuncelement + : colid typename opt_collate_clause + ; + +xmltable + : XMLTABLE OPEN_PAREN (c_expr xmlexists_argument COLUMNS xmltable_column_list | XMLNAMESPACES OPEN_PAREN xml_namespace_list CLOSE_PAREN COMMA c_expr xmlexists_argument COLUMNS xmltable_column_list) CLOSE_PAREN + ; + +xmltable_column_list + : xmltable_column_el (COMMA xmltable_column_el)* + ; + +xmltable_column_el + : colid (typename xmltable_column_option_list? | FOR ORDINALITY) + ; + +xmltable_column_option_list + : xmltable_column_option_el+ + ; + +xmltable_column_option_el + : DEFAULT a_expr + | identifier a_expr + | NOT NULL_P + | NULL_P + ; + +xml_namespace_list + : xml_namespace_el (COMMA xml_namespace_el)* + ; + +xml_namespace_el + : b_expr AS collabel + | DEFAULT b_expr + ; + +typename + : SETOF? simpletypename (opt_array_bounds | ARRAY (OPEN_BRACKET iconst CLOSE_BRACKET)?) + | qualified_name PERCENT (ROWTYPE | TYPE_P) + ; + +opt_array_bounds + : (OPEN_BRACKET iconst? CLOSE_BRACKET)* + ; + +simpletypename + : generictype + | numeric + | bit + | character + | constdatetime + | constinterval (opt_interval | OPEN_PAREN iconst CLOSE_PAREN) + ; + +consttypename + : numeric + | constbit + | constcharacter + | constdatetime + ; + +generictype + : type_function_name attrs? opt_type_modifiers + ; + +opt_type_modifiers + : OPEN_PAREN expr_list CLOSE_PAREN + | + ; + +numeric + : INT_P + | INTEGER + | SMALLINT + | BIGINT + | REAL + | FLOAT_P opt_float + | DOUBLE_P PRECISION + | DECIMAL_P opt_type_modifiers + | DEC opt_type_modifiers + | NUMERIC opt_type_modifiers + | BOOLEAN_P + ; + +opt_float + : OPEN_PAREN iconst CLOSE_PAREN + | + ; + //todo: merge alts + +bit + : bitwithlength + | bitwithoutlength + ; + +constbit + : bitwithlength + | bitwithoutlength + ; + +bitwithlength + : BIT opt_varying OPEN_PAREN expr_list CLOSE_PAREN + ; + +bitwithoutlength + : BIT opt_varying + ; + +character + : character_c (OPEN_PAREN iconst CLOSE_PAREN)? + ; + +constcharacter + : character_c (OPEN_PAREN iconst CLOSE_PAREN)? + ; + +character_c + : (CHARACTER | CHAR_P | NCHAR) opt_varying + | VARCHAR + | NATIONAL (CHARACTER | CHAR_P) opt_varying + ; + +opt_varying + : VARYING + | + ; + +constdatetime + : (TIMESTAMP | TIME) (OPEN_PAREN iconst CLOSE_PAREN)? opt_timezone + ; + +constinterval + : INTERVAL + ; + //TODO with_la was used + +opt_timezone + : WITH TIME ZONE + | WITHOUT TIME ZONE + | + ; + +opt_interval + : YEAR_P + | MONTH_P + | DAY_P + | HOUR_P + | MINUTE_P + | interval_second + | YEAR_P TO MONTH_P + | DAY_P TO (HOUR_P | MINUTE_P | interval_second) + | HOUR_P TO (MINUTE_P | interval_second) + | MINUTE_P TO interval_second + | + ; + +interval_second + : SECOND_P (OPEN_PAREN iconst CLOSE_PAREN)? + ; + +opt_escape + : ESCAPE a_expr + | + ; + //precendence accroding to Table 4.2. Operator Precedence (highest to lowest) + + //https://www.postgresql.org/docs/12/sql-syntax-lexical.html#SQL-PRECEDENCE + +/* +original version of a_expr, for info + a_expr: c_expr + //:: left PostgreSQL-style typecast + | a_expr TYPECAST typename -- 1 + | a_expr COLLATE any_name -- 2 + | a_expr AT TIME ZONE a_expr-- 3 + //right unary plus, unary minus + | (PLUS| MINUS) a_expr -- 4 + //left exponentiation + | a_expr CARET a_expr -- 5 + //left multiplication, division, modulo + | a_expr (STAR | SLASH | PERCENT) a_expr -- 6 + //left addition, subtraction + | a_expr (PLUS | MINUS) a_expr -- 7 + //left all other native and user-defined operators + | a_expr qual_op a_expr -- 8 + | qual_op a_expr -- 9 + //range containment, set membership, string matching BETWEEN IN LIKE ILIKE SIMILAR + | a_expr NOT? (LIKE|ILIKE|SIMILAR TO|(BETWEEN SYMMETRIC?)) a_expr opt_escape -- 10 + //< > = <= >= <> comparison operators + | a_expr (LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) a_expr -- 11 + //IS ISNULL NOTNULL IS TRUE, IS FALSE, IS NULL, IS DISTINCT FROM, etc + | a_expr IS NOT? + ( + NULL_P + |TRUE_P + |FALSE_P + |UNKNOWN + |DISTINCT FROM a_expr + |OF OPEN_PAREN type_list CLOSE_PAREN + |DOCUMENT_P + |unicode_normal_form? NORMALIZED + ) -- 12 + | a_expr (ISNULL|NOTNULL) -- 13 + | row OVERLAPS row -- 14 + //NOT right logical negation + | NOT a_expr -- 15 + //AND left logical conjunction + | a_expr AND a_expr -- 16 + //OR left logical disjunction + | a_expr OR a_expr -- 17 + | a_expr (LESS_LESS|GREATER_GREATER) a_expr -- 18 + | a_expr qual_op -- 19 + | a_expr NOT? IN_P in_expr -- 20 + | a_expr subquery_Op sub_type (select_with_parens|OPEN_PAREN a_expr CLOSE_PAREN) -- 21 + | UNIQUE select_with_parens -- 22 + | DEFAULT -- 23 +; +*/ + + +a_expr + : a_expr_qual + ; +/*23*/ + + +/*moved to c_expr*/ + + +/*22*/ + + +/*moved to c_expr*/ + + +/*19*/ + + +a_expr_qual + : a_expr_lessless qual_op? + ; +/*18*/ + + +a_expr_lessless + : a_expr_or ((LESS_LESS | GREATER_GREATER) a_expr_or)* + ; +/*17*/ + + +a_expr_or + : a_expr_and (OR a_expr_and)* + ; +/*16*/ + + +a_expr_and + : a_expr_in (AND a_expr_in)* + ; +/*20*/ + + +a_expr_in + : a_expr_unary_not (NOT? IN_P in_expr)? + ; +/*15*/ + + +a_expr_unary_not + : NOT? a_expr_isnull + ; +/*14*/ + + +/*moved to c_expr*/ + + +/*13*/ + + +a_expr_isnull + : a_expr_is_not (ISNULL | NOTNULL)? + ; +/*12*/ + + +a_expr_is_not + : a_expr_compare (IS NOT? (NULL_P | TRUE_P | FALSE_P | UNKNOWN | DISTINCT FROM a_expr | OF OPEN_PAREN type_list CLOSE_PAREN | DOCUMENT_P | unicode_normal_form? NORMALIZED))? + ; +/*11*/ + + +a_expr_compare + : a_expr_like ((LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) a_expr_like |subquery_Op sub_type (select_with_parens | OPEN_PAREN a_expr CLOSE_PAREN) /*21*/ + + )? + ; +/*10*/ + + +a_expr_like + : a_expr_qual_op (NOT? (LIKE | ILIKE | SIMILAR TO | BETWEEN SYMMETRIC?) a_expr_qual_op opt_escape)? + ; +/* 8*/ + + +a_expr_qual_op + : a_expr_unary_qualop (qual_op a_expr_unary_qualop)* + ; +/* 9*/ + + +a_expr_unary_qualop + : qual_op? a_expr_add + ; +/* 7*/ + + +a_expr_add + : a_expr_mul ((MINUS | PLUS) a_expr_mul)* + ; +/* 6*/ + + +a_expr_mul + : a_expr_caret ((STAR | SLASH | PERCENT) a_expr_caret)* + ; +/* 5*/ + + +a_expr_caret + : a_expr_unary_sign (CARET a_expr)? + ; +/* 4*/ + + +a_expr_unary_sign + : (MINUS | PLUS)? a_expr_at_time_zone /* */ + + + ; +/* 3*/ + + +a_expr_at_time_zone + : a_expr_collate (AT TIME ZONE a_expr)? + ; +/* 2*/ + + +a_expr_collate + : a_expr_typecast (COLLATE any_name)? + ; +/* 1*/ + + +a_expr_typecast + : c_expr (TYPECAST typename)* + ; + +b_expr + : c_expr + | b_expr TYPECAST typename + //right unary plus, unary minus + | (PLUS | MINUS) b_expr + //^ left exponentiation + | b_expr CARET b_expr + //* / % left multiplication, division, modulo + | b_expr (STAR | SLASH | PERCENT) b_expr + //+ - left addition, subtraction + | b_expr (PLUS | MINUS) b_expr + //(any other operator) left all other native and user-defined operators + | b_expr qual_op b_expr + //< > = <= >= <> comparison operators + | b_expr (LT | GT | EQUAL | LESS_EQUALS | GREATER_EQUALS | NOT_EQUALS) b_expr + | qual_op b_expr + | b_expr qual_op + //S ISNULL NOTNULL IS TRUE, IS FALSE, IS NULL, IS DISTINCT FROM, etc + | b_expr IS NOT? (DISTINCT FROM b_expr | OF OPEN_PAREN type_list CLOSE_PAREN | DOCUMENT_P) + ; + +c_expr + : EXISTS select_with_parens # c_expr_exists + | ARRAY (select_with_parens | array_expr) # c_expr_expr + | PARAM opt_indirection # c_expr_expr + | GROUPING OPEN_PAREN expr_list CLOSE_PAREN # c_expr_expr + | /*22*/ + + UNIQUE select_with_parens # c_expr_expr + | columnref # c_expr_expr + | aexprconst # c_expr_expr + | plsqlvariablename # c_expr_expr + | OPEN_PAREN a_expr_in_parens = a_expr CLOSE_PAREN opt_indirection # c_expr_expr + | case_expr # c_expr_case + | func_expr # c_expr_expr + | select_with_parens indirection? # c_expr_expr + | explicit_row # c_expr_expr + | implicit_row # c_expr_expr + | row OVERLAPS row /* 14*/ + + # c_expr_expr + ; + +plsqlvariablename + : PLSQLVARIABLENAME + ; + +func_application + : func_name OPEN_PAREN (func_arg_list (COMMA VARIADIC func_arg_expr)? opt_sort_clause | VARIADIC func_arg_expr opt_sort_clause | (ALL | DISTINCT) func_arg_list opt_sort_clause | STAR |) CLOSE_PAREN + ; + +func_expr + : func_application within_group_clause filter_clause over_clause + | func_expr_common_subexpr + ; + +func_expr_windowless + : func_application + | func_expr_common_subexpr + ; + +func_expr_common_subexpr + : COLLATION FOR OPEN_PAREN a_expr CLOSE_PAREN + | CURRENT_DATE + | CURRENT_TIME (OPEN_PAREN iconst CLOSE_PAREN)? + | CURRENT_TIMESTAMP (OPEN_PAREN iconst CLOSE_PAREN)? + | LOCALTIME (OPEN_PAREN iconst CLOSE_PAREN)? + | LOCALTIMESTAMP (OPEN_PAREN iconst CLOSE_PAREN)? + | CURRENT_ROLE + | CURRENT_USER + | SESSION_USER + | USER + | CURRENT_CATALOG + | CURRENT_SCHEMA + | CAST OPEN_PAREN a_expr AS typename CLOSE_PAREN + | EXTRACT OPEN_PAREN extract_list CLOSE_PAREN + | NORMALIZE OPEN_PAREN a_expr (COMMA unicode_normal_form)? CLOSE_PAREN + | OVERLAY OPEN_PAREN overlay_list CLOSE_PAREN + | POSITION OPEN_PAREN position_list CLOSE_PAREN + | SUBSTRING OPEN_PAREN substr_list CLOSE_PAREN + | TREAT OPEN_PAREN a_expr AS typename CLOSE_PAREN + | TRIM OPEN_PAREN (BOTH | LEADING | TRAILING)? trim_list CLOSE_PAREN + | NULLIF OPEN_PAREN a_expr COMMA a_expr CLOSE_PAREN + | COALESCE OPEN_PAREN expr_list CLOSE_PAREN + | GREATEST OPEN_PAREN expr_list CLOSE_PAREN + | LEAST OPEN_PAREN expr_list CLOSE_PAREN + | XMLCONCAT OPEN_PAREN expr_list CLOSE_PAREN + | XMLELEMENT OPEN_PAREN NAME_P collabel (COMMA (xml_attributes | expr_list))? CLOSE_PAREN + | XMLEXISTS OPEN_PAREN c_expr xmlexists_argument CLOSE_PAREN + | XMLFOREST OPEN_PAREN xml_attribute_list CLOSE_PAREN + | XMLPARSE OPEN_PAREN document_or_content a_expr xml_whitespace_option CLOSE_PAREN + | XMLPI OPEN_PAREN NAME_P collabel (COMMA a_expr)? CLOSE_PAREN + | XMLROOT OPEN_PAREN XML_P a_expr COMMA xml_root_version opt_xml_root_standalone CLOSE_PAREN + | XMLSERIALIZE OPEN_PAREN document_or_content a_expr AS simpletypename CLOSE_PAREN + ; + +xml_root_version + : VERSION_P a_expr + | VERSION_P NO VALUE_P + ; + +opt_xml_root_standalone + : COMMA STANDALONE_P YES_P + | COMMA STANDALONE_P NO + | COMMA STANDALONE_P NO VALUE_P + | + ; + +xml_attributes + : XMLATTRIBUTES OPEN_PAREN xml_attribute_list CLOSE_PAREN + ; + +xml_attribute_list + : xml_attribute_el (COMMA xml_attribute_el)* + ; + +xml_attribute_el + : a_expr (AS collabel)? + ; + +document_or_content + : DOCUMENT_P + | CONTENT_P + ; + +xml_whitespace_option + : PRESERVE WHITESPACE_P + | STRIP_P WHITESPACE_P + | + ; + +xmlexists_argument + : PASSING c_expr + | PASSING c_expr xml_passing_mech + | PASSING xml_passing_mech c_expr + | PASSING xml_passing_mech c_expr xml_passing_mech + ; + +xml_passing_mech + : BY (REF | VALUE_P) + ; + +within_group_clause + : WITHIN GROUP_P OPEN_PAREN sort_clause CLOSE_PAREN + | + ; + +filter_clause + : FILTER OPEN_PAREN WHERE a_expr CLOSE_PAREN + | + ; + +window_clause + : WINDOW window_definition_list + | + ; + +window_definition_list + : window_definition (COMMA window_definition)* + ; + +window_definition + : colid AS window_specification + ; + +over_clause + : OVER (window_specification | colid) + | + ; + +window_specification + : OPEN_PAREN opt_existing_window_name opt_partition_clause opt_sort_clause opt_frame_clause CLOSE_PAREN + ; + +opt_existing_window_name + : colid + | + ; + +opt_partition_clause + : PARTITION BY expr_list + | + ; + +opt_frame_clause + : RANGE frame_extent opt_window_exclusion_clause + | ROWS frame_extent opt_window_exclusion_clause + | GROUPS frame_extent opt_window_exclusion_clause + | + ; + +frame_extent + : frame_bound + | BETWEEN frame_bound AND frame_bound + ; + +frame_bound + : UNBOUNDED (PRECEDING | FOLLOWING) + | CURRENT_P ROW + | a_expr (PRECEDING | FOLLOWING) + ; + +opt_window_exclusion_clause + : EXCLUDE (CURRENT_P ROW | GROUP_P | TIES | NO OTHERS) + | + ; + +row + : ROW OPEN_PAREN expr_list? CLOSE_PAREN + | OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN + ; + +explicit_row + : ROW OPEN_PAREN expr_list? CLOSE_PAREN + ; +/* +TODO: +for some reason v1 +implicit_row: OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN; +works better than v2 +implicit_row: OPEN_PAREN expr_list CLOSE_PAREN; +while looks like they are almost the same, except v2 requieres at least 2 items in list +while v1 allows single item in list +*/ + + +implicit_row + : OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN + ; + +sub_type + : ANY + | SOME + | ALL + ; + +all_op + : Operator + | mathop + ; + +mathop + : PLUS + | MINUS + | STAR + | SLASH + | PERCENT + | CARET + | LT + | GT + | EQUAL + | LESS_EQUALS + | GREATER_EQUALS + | NOT_EQUALS + ; + +qual_op + : Operator + | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + ; + +qual_all_op + : all_op + | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + ; + +subquery_Op + : all_op + | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + | LIKE + | NOT LIKE + | ILIKE + | NOT ILIKE + ; + +expr_list + : a_expr (COMMA a_expr)* + ; + +func_arg_list + : func_arg_expr (COMMA func_arg_expr)* + ; + +func_arg_expr + : a_expr + | param_name (COLON_EQUALS | EQUALS_GREATER) a_expr + ; + +type_list + : typename (COMMA typename)* + ; + +array_expr + : OPEN_BRACKET (expr_list | array_expr_list)? CLOSE_BRACKET + ; + +array_expr_list + : array_expr (COMMA array_expr)* + ; + +extract_list + : extract_arg FROM a_expr + | + ; + +extract_arg + : identifier + | YEAR_P + | MONTH_P + | DAY_P + | HOUR_P + | MINUTE_P + | SECOND_P + | sconst + ; + +unicode_normal_form + : NFC + | NFD + | NFKC + | NFKD + ; + +overlay_list + : a_expr PLACING a_expr FROM a_expr (FOR a_expr)? + ; + +position_list + : b_expr IN_P b_expr + | + ; + +substr_list + : a_expr FROM a_expr FOR a_expr + | a_expr FOR a_expr FROM a_expr + | a_expr FROM a_expr + | a_expr FOR a_expr + | a_expr SIMILAR a_expr ESCAPE a_expr + | expr_list + | + ; + +trim_list + : a_expr FROM expr_list + | FROM expr_list + | expr_list + ; + +in_expr + : select_with_parens # in_expr_select + | OPEN_PAREN expr_list CLOSE_PAREN # in_expr_list + ; + +case_expr + : CASE case_arg when_clause_list case_default END_P + ; + +when_clause_list + : when_clause+ + ; + +when_clause + : WHEN a_expr THEN a_expr + ; + +case_default + : ELSE a_expr + | + ; + +case_arg + : a_expr + | + ; + +columnref + : colid indirection? + ; + +indirection_el + : DOT (attr_name | STAR) + | OPEN_BRACKET (a_expr | opt_slice_bound COLON opt_slice_bound) CLOSE_BRACKET + ; + +opt_slice_bound + : a_expr + | + ; + +indirection + : indirection_el+ + ; + +opt_indirection + : indirection_el* + ; + +opt_target_list + : target_list + | + ; + +target_list + : target_el (COMMA target_el)* + ; + +target_el + : a_expr (AS collabel | identifier |) # target_label + | STAR # target_star + ; + +qualified_name_list + : qualified_name (COMMA qualified_name)* + ; + +qualified_name + : colid indirection? + ; + +name_list + : name (COMMA name)* + ; + +name + : colid + ; + +attr_name + : collabel + ; + +file_name + : sconst + ; + +func_name + : type_function_name + | colid indirection + ; + +aexprconst + : iconst + | fconst + | sconst + | bconst + | xconst + | func_name (sconst | OPEN_PAREN func_arg_list opt_sort_clause CLOSE_PAREN sconst) + | consttypename sconst + | constinterval (sconst opt_interval | OPEN_PAREN iconst CLOSE_PAREN sconst) + | TRUE_P + | FALSE_P + | NULL_P + ; + +xconst + : HexadecimalStringConstant + ; + +bconst + : BinaryStringConstant + ; + +fconst + : Numeric + ; + +iconst + : Integral + ; + +sconst + : anysconst opt_uescape + ; + +anysconst + : StringConstant + | UnicodeEscapeStringConstant + | BeginDollarStringConstant DollarText* EndDollarStringConstant + | EscapeStringConstant + ; + +opt_uescape + : UESCAPE anysconst + | + ; + +signediconst + : iconst + | PLUS iconst + | MINUS iconst + ; + +roleid + : rolespec + ; + +rolespec + : nonreservedword + | CURRENT_USER + | SESSION_USER + ; + +role_list + : rolespec (COMMA rolespec)* + ; + +colid + : identifier + | unreserved_keyword + | col_name_keyword + | plsql_unreserved_keyword + ; + +type_function_name + : identifier + | unreserved_keyword + | plsql_unreserved_keyword + | type_func_name_keyword + ; + +nonreservedword + : identifier + | unreserved_keyword + | col_name_keyword + | type_func_name_keyword + ; + +collabel + : identifier + | plsql_unreserved_keyword + | unreserved_keyword + | col_name_keyword + | type_func_name_keyword + | reserved_keyword + ; + +identifier + : Identifier opt_uescape + | QuotedIdentifier + | UnicodeQuotedIdentifier + | plsqlvariablename + | plsqlidentifier + | plsql_unreserved_keyword + ; + +plsqlidentifier + : PLSQLIDENTIFIER + ; + +unreserved_keyword + : ABORT_P + | ABSOLUTE_P + | ACCESS + | ACTION + | ADD_P + | ADMIN + | AFTER + | AGGREGATE + | ALSO + | ALTER + | ALWAYS + | ASSERTION + | ASSIGNMENT + | AT + | ATTACH + | ATTRIBUTE + | BACKWARD + | BEFORE + | BEGIN_P + | BY + | CACHE + | CALL + | CALLED + | CASCADE + | CASCADED + | CATALOG + | CHAIN + | CHARACTERISTICS + | CHECKPOINT + | CLASS + | CLOSE + | CLUSTER + | COLUMNS + | COMMENT + | COMMENTS + | COMMIT + | COMMITTED + | CONFIGURATION + | CONFLICT + | CONNECTION + | CONSTRAINTS + | CONTENT_P + | CONTINUE_P + | CONVERSION_P + | COPY + | COST + | CSV + | CUBE + | CURRENT_P + | CURSOR + | CYCLE + | DATA_P + | DATABASE + | DAY_P + | DEALLOCATE + | DECLARE + | DEFAULTS + | DEFERRED + | DEFINER + | DELETE_P + | DELIMITER + | DELIMITERS + | DEPENDS + | DETACH + | DICTIONARY + | DISABLE_P + | DISCARD + | DOCUMENT_P + | DOMAIN_P + | DOUBLE_P + | DROP + | EACH + | ENABLE_P + | ENCODING + | ENCRYPTED + | ENUM_P + | ESCAPE + | EVENT + | EXCLUDE + | EXCLUDING + | EXCLUSIVE + | EXECUTE + | EXPLAIN + | EXPRESSION + | EXTENSION + | EXTERNAL + | FAMILY + | FILTER + | FIRST_P + | FOLLOWING + | FORCE + | FORWARD + | FUNCTION + | FUNCTIONS + | GENERATED + | GLOBAL + | GRANTED + | GROUPS + | HANDLER + | HEADER_P + | HOLD + | HOUR_P + | IDENTITY_P + | IF_P + | IMMEDIATE + | IMMUTABLE + | IMPLICIT_P + | IMPORT_P + | INCLUDE + | INCLUDING + | INCREMENT + | INDEX + | INDEXES + | INHERIT + | INHERITS + | INLINE_P + | INPUT_P + | INSENSITIVE + | INSERT + | INSTEAD + | INVOKER + | ISOLATION + | KEY + | LABEL + | LANGUAGE + | LARGE_P + | LAST_P + | LEAKPROOF + | LEVEL + | LISTEN + | LOAD + | LOCAL + | LOCATION + | LOCK_P + | LOCKED + | LOGGED + | MAPPING + | MATCH + | MATERIALIZED + | MAXVALUE + | METHOD + | MINUTE_P + | MINVALUE + | MODE + | MONTH_P + | MOVE + | NAME_P + | NAMES + | NEW + | NEXT + | NFC + | NFD + | NFKC + | NFKD + | NO + | NORMALIZED + | NOTHING + | NOTIFY + | NOWAIT + | NULLS_P + | OBJECT_P + | OF + | OFF + | OIDS + | OLD + | OPERATOR + | OPTION + | OPTIONS + | ORDINALITY + | OTHERS + | OVER + | OVERRIDING + | OWNED + | OWNER + | PARALLEL + | PARSER + | PARTIAL + | PARTITION + | PASSING + | PASSWORD + | PLANS + | POLICY + | PRECEDING + | PREPARE + | PREPARED + | PRESERVE + | PRIOR + | PRIVILEGES + | PROCEDURAL + | PROCEDURE + | PROCEDURES + | PROGRAM + | PUBLICATION + | QUOTE + | RANGE + | READ + | REASSIGN + | RECHECK + | RECURSIVE + | REF + | REFERENCING + | REFRESH + | REINDEX + | RELATIVE_P + | RELEASE + | RENAME + | REPEATABLE + | REPLACE + | REPLICA + | RESET + | RESTART + | RESTRICT + | RETURNS + | REVOKE + | ROLE + | ROLLBACK + | ROLLUP + | ROUTINE + | ROUTINES + | ROWS + | RULE + | SAVEPOINT + | SCHEMA + | SCHEMAS + | SCROLL + | SEARCH + | SECOND_P + | SECURITY + | SEQUENCE + | SEQUENCES + | SERIALIZABLE + | SERVER + | SESSION + | SET + | SETS + | SHARE + | SHOW + | SIMPLE + | SKIP_P + | SNAPSHOT + | SQL_P + | STABLE + | STANDALONE_P + | START + | STATEMENT + | STATISTICS + | STDIN + | STDOUT + | STORAGE + | STORED + | STRICT_P + | STRIP_P + | SUBSCRIPTION + | SUPPORT + | SYSID + | SYSTEM_P + | TABLES + | TABLESPACE + | TEMP + | TEMPLATE + | TEMPORARY + | TEXT_P + | TIES + | TRANSACTION + | TRANSFORM + | TRIGGER + | TRUNCATE + | TRUSTED + | TYPE_P + | TYPES_P + | UESCAPE + | UNBOUNDED + | UNCOMMITTED + | UNENCRYPTED + | UNKNOWN + | UNLISTEN + | UNLOGGED + | UNTIL + | UPDATE + | VACUUM + | VALID + | VALIDATE + | VALIDATOR + | VALUE_P + | VARYING + | VERSION_P + | VIEW + | VIEWS + | VOLATILE + | WHITESPACE_P + | WITHIN + | WITHOUT + | WORK + | WRAPPER + | WRITE + | XML_P + | YEAR_P + | YES_P + | ZONE + ; + +col_name_keyword + : BETWEEN + | BIGINT + | bit + | BOOLEAN_P + | CHAR_P + | character + | COALESCE + | DEC + | DECIMAL_P + | EXISTS + | EXTRACT + | FLOAT_P + | GREATEST + | GROUPING + | INOUT + | INT_P + | INTEGER + | INTERVAL + | LEAST + | NATIONAL + | NCHAR + | NONE + | NORMALIZE + | NULLIF + | numeric + | OUT_P + | OVERLAY + | POSITION + | PRECISION + | REAL + | ROW + | SETOF + | SMALLINT + | SUBSTRING + | TIME + | TIMESTAMP + | TREAT + | TRIM + | VALUES + | VARCHAR + | XMLATTRIBUTES + | XMLCONCAT + | XMLELEMENT + | XMLEXISTS + | XMLFOREST + | XMLNAMESPACES + | XMLPARSE + | XMLPI + | XMLROOT + | XMLSERIALIZE + | XMLTABLE + ; + +type_func_name_keyword + : AUTHORIZATION + | BINARY + | COLLATION + | CONCURRENTLY + | CROSS + | CURRENT_SCHEMA + | FREEZE + | FULL + | ILIKE + | INNER_P + | IS + | ISNULL + | JOIN + | LEFT + | LIKE + | NATURAL + | NOTNULL + | OUTER_P + | OVERLAPS + | RIGHT + | SIMILAR + | TABLESAMPLE + | VERBOSE + ; + +reserved_keyword + : ALL + | ANALYSE + | ANALYZE + | AND + | ANY + | ARRAY + | AS + | ASC + | ASYMMETRIC + | BOTH + | CASE + | CAST + | CHECK + | COLLATE + | COLUMN + | CONSTRAINT + | CREATE + | CURRENT_CATALOG + | CURRENT_DATE + | CURRENT_ROLE + | CURRENT_TIME + | CURRENT_TIMESTAMP + | CURRENT_USER + // | DEFAULT + | DEFERRABLE + | DESC + | DISTINCT + | DO + | ELSE + | END_P + | EXCEPT + | FALSE_P + | FETCH + | FOR + | FOREIGN + | FROM + | GRANT + | GROUP_P + | HAVING + | IN_P + | INITIALLY + | INTERSECT +/* +from pl_gram.y, line ~2982 + * Fortunately, INTO is a fully reserved word in the main grammar, so + * at least we need not worry about it appearing as an identifier. +*/ + + + // | INTO + | LATERAL_P + | LEADING + | LIMIT + | LOCALTIME + | LOCALTIMESTAMP + | NOT + | NULL_P + | OFFSET + | ON + | ONLY + | OR + | ORDER + | PLACING + | PRIMARY + | REFERENCES + | RETURNING + | SELECT + | SESSION_USER + | SOME + | SYMMETRIC + | TABLE + | THEN + | TO + | TRAILING + | TRUE_P + | UNION + | UNIQUE + | USER + | USING + | VARIADIC + | WHEN + | WHERE + | WINDOW + | WITH + ; + +/************************************************************************************************************************************************************/ +/*PL/SQL GRAMMAR */ + + +/*PLSQL grammar */ + + /************************************************************************************************************************************************************/ pl_function + : comp_options pl_block opt_semi + ; + +comp_options + : comp_option* + ; + +comp_option + : sharp OPTION DUMP + | sharp PRINT_STRICT_PARAMS option_value + | sharp VARIABLE_CONFLICT ERROR + | sharp VARIABLE_CONFLICT USE_VARIABLE + | sharp VARIABLE_CONFLICT USE_COLUMN + ; + +sharp + : Operator + ; + +option_value + : sconst + | reserved_keyword + | plsql_unreserved_keyword + | unreserved_keyword + ; + +opt_semi + : + | SEMI + ; + // exception_sect means opt_exception_sect in original grammar, don't be confused! + +pl_block + : decl_sect BEGIN_P proc_sect exception_sect END_P opt_label + ; + +decl_sect + : opt_block_label (decl_start decl_stmts?)? + ; + +decl_start + : DECLARE + ; + +decl_stmts + : decl_stmt+ + ; + +label_decl + : LESS_LESS any_identifier GREATER_GREATER + ; + +decl_stmt + : decl_statement + | DECLARE + | label_decl + ; + +decl_statement + : decl_varname + ( + ALIAS FOR decl_aliasitem + | decl_const decl_datatype decl_collate decl_notnull decl_defval + | opt_scrollable CURSOR decl_cursor_args decl_is_for decl_cursor_query + ) SEMI + ; + +opt_scrollable + : + | NO SCROLL + | SCROLL + ; + +decl_cursor_query + : selectstmt + ; + +decl_cursor_args + : + | OPEN_PAREN decl_cursor_arglist CLOSE_PAREN + ; + +decl_cursor_arglist + : decl_cursor_arg (COMMA decl_cursor_arg)* + ; + +decl_cursor_arg + : decl_varname decl_datatype + ; + +decl_is_for + : IS + | FOR + ; + +decl_aliasitem + : PARAM + | colid + ; + +decl_varname + : any_identifier + ; + +decl_const + : + | CONSTANT + ; + +decl_datatype + : typename + ; //TODO: $$ = read_datatype(yychar); + +decl_collate + : + | COLLATE any_name + ; + +decl_notnull + : + | NOT NULL_P + ; + +decl_defval + : + | decl_defkey sql_expression + ; + +decl_defkey + : assign_operator + | DEFAULT + ; + +assign_operator + : EQUAL + | COLON_EQUALS + ; + +proc_sect + : proc_stmt* + ; + +proc_stmt + : pl_block SEMI + | stmt_return + | stmt_raise + | stmt_assign + | stmt_if + | stmt_case + | stmt_loop + | stmt_while + | stmt_for + | stmt_foreach_a + | stmt_exit + | stmt_assert + | stmt_execsql + | stmt_dynexecute + | stmt_perform + | stmt_call + | stmt_getdiag + | stmt_open + | stmt_fetch + | stmt_move + | stmt_close + | stmt_null + | stmt_commit + | stmt_rollback + | stmt_set + ; + +stmt_perform + : PERFORM expr_until_semi SEMI + ; + +stmt_call + : CALL any_identifier OPEN_PAREN opt_expr_list CLOSE_PAREN SEMI + | DO any_identifier OPEN_PAREN opt_expr_list CLOSE_PAREN SEMI + ; + +opt_expr_list + : + | expr_list + ; + +stmt_assign + : assign_var assign_operator sql_expression SEMI + ; + +stmt_getdiag + : GET getdiag_area_opt DIAGNOSTICS getdiag_list SEMI + ; + +getdiag_area_opt + : + | CURRENT_P + | STACKED + ; + +getdiag_list + : getdiag_list_item (COMMA getdiag_list_item)* + ; + +getdiag_list_item + : getdiag_target assign_operator getdiag_item + ; + +getdiag_item + : colid + ; + +getdiag_target + : assign_var + ; + +assign_var + : (any_name | PARAM) (OPEN_BRACKET expr_until_rightbracket CLOSE_BRACKET)* + ; + +stmt_if + : IF_P expr_until_then THEN proc_sect stmt_elsifs stmt_else END_P IF_P SEMI + ; + +stmt_elsifs + : (ELSIF a_expr THEN proc_sect)* + ; + +stmt_else + : + | ELSE proc_sect + ; + +stmt_case + : CASE opt_expr_until_when case_when_list opt_case_else END_P CASE SEMI + ; + +opt_expr_until_when + : + | sql_expression + ; + +case_when_list + : case_when+ + ; + +case_when + : WHEN expr_list THEN proc_sect + ; + +opt_case_else + : + | ELSE proc_sect + ; + +stmt_loop + : opt_loop_label loop_body + ; + +stmt_while + : opt_loop_label WHILE expr_until_loop loop_body + ; + +stmt_for + : opt_loop_label FOR for_control loop_body + ; + //TODO: rewrite using read_sql_expression logic? + +for_control + : for_variable IN_P + ( + cursor_name opt_cursor_parameters + | selectstmt + | explainstmt + | EXECUTE a_expr opt_for_using_expression + | opt_reverse a_expr DOT_DOT a_expr opt_by_expression + ) + ; + +opt_for_using_expression + : + | USING expr_list + ; + +opt_cursor_parameters + : + | OPEN_PAREN a_expr (COMMA a_expr)* CLOSE_PAREN + ; + +opt_reverse + : + | REVERSE + ; + +opt_by_expression + : + | BY a_expr + ; + +for_variable + : any_name_list + ; + +stmt_foreach_a + : opt_loop_label FOREACH for_variable foreach_slice IN_P ARRAY a_expr loop_body + ; + +foreach_slice + : + | SLICE iconst + ; + +stmt_exit + : exit_type opt_label opt_exitcond SEMI + ; + +exit_type + : EXIT + | CONTINUE_P + ; + //todo implement RETURN statement according to initial grammar line 1754 + +stmt_return + : RETURN (NEXT sql_expression | QUERY (EXECUTE a_expr opt_for_using_expression | selectstmt) | opt_return_result) SEMI + ; + +opt_return_result + : + | sql_expression + ; + //https://www.postgresql.org/docs/current/plpgsql-errors-and-messages.html + + //RAISE [ level ] 'format' [, expression [, ... ]] [ USING option = expression [, ... ] ]; + + //RAISE [ level ] condition_name [ USING option = expression [, ... ] ]; + + //RAISE [ level ] SQLSTATE 'sqlstate' [ USING option = expression [, ... ] ]; + + //RAISE [ level ] USING option = expression [, ... ]; + + //RAISE ; + +stmt_raise + : RAISE opt_stmt_raise_level sconst opt_raise_list opt_raise_using SEMI + | RAISE opt_stmt_raise_level identifier opt_raise_using SEMI + | RAISE opt_stmt_raise_level SQLSTATE sconst opt_raise_using SEMI + | RAISE opt_stmt_raise_level opt_raise_using SEMI + | RAISE + ; + +opt_stmt_raise_level + : + | + | DEBUG + | LOG + | INFO + | NOTICE + | WARNING + | EXCEPTION + ; + +opt_raise_list + : + | (COMMA a_expr)+ + ; + +opt_raise_using + : + | USING opt_raise_using_elem_list + ; + +opt_raise_using_elem + : identifier EQUAL a_expr + ; + +opt_raise_using_elem_list + : opt_raise_using_elem (COMMA opt_raise_using_elem)* + ; + //todo imnplement + +stmt_assert + : ASSERT sql_expression opt_stmt_assert_message SEMI + ; + +opt_stmt_assert_message + : + | COMMA sql_expression + ; + +loop_body + : LOOP proc_sect END_P LOOP opt_label SEMI + ; + //TODO: looks like all other statements like INSERT/SELECT/UPDATE/DELETE are handled here; + + //pls take a look at original grammar + +stmt_execsql + : make_execsql_stmt SEMI +/*K_IMPORT + | K_INSERT + | t_word + | t_cword +*/ + + + ; + //https://www.postgresql.org/docs/current/plpgsql-statements.html#PLPGSQL-STATEMENTS-SQL-NORESULT + + //EXECUTE command-string [ INTO [STRICT] target ] [ USING expression [, ... ] ]; + +stmt_dynexecute + : EXECUTE a_expr ( +/*this is silly, but i have to time to find nice way to code */ + + opt_execute_into opt_execute_using | opt_execute_using opt_execute_into |) SEMI + ; + +opt_execute_using + : + | USING opt_execute_using_list + ; + +opt_execute_using_list + : a_expr (COMMA a_expr)* + ; + +opt_execute_into + : + | INTO STRICT_P? into_target + ; + //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING + + //OPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR query; + + //OPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR EXECUTE query_string + + // [ USING expression [, ... ] ]; + + //OPEN bound_cursorvar [ ( [ argument_name := ] argument_value [, ...] ) ]; + +stmt_open + : OPEN + ( + cursor_variable opt_scroll_option FOR (selectstmt | EXECUTE sql_expression opt_open_using) + | colid (OPEN_PAREN opt_open_bound_list CLOSE_PAREN)? + ) SEMI + ; + +opt_open_bound_list_item + : colid COLON_EQUALS a_expr + | a_expr + ; + +opt_open_bound_list + : opt_open_bound_list_item (COMMA opt_open_bound_list_item)* + ; + +opt_open_using + : + | USING expr_list + ; + +opt_scroll_option + : + | opt_scroll_option_no SCROLL + ; + +opt_scroll_option_no + : + | NO + ; + //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING + + //FETCH [ direction { FROM | IN } ] cursor INTO target; + +stmt_fetch + : FETCH direction = opt_fetch_direction opt_cursor_from cursor_variable INTO into_target SEMI + ; + +into_target + : expr_list + ; + +opt_cursor_from + : + | FROM + | IN_P + ; + +opt_fetch_direction + : + | + | NEXT + | PRIOR + | FIRST_P + | LAST_P + | ABSOLUTE_P a_expr + | RELATIVE_P a_expr + | a_expr + | ALL + | (FORWARD | BACKWARD) (a_expr | ALL)? + ; + //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING + + //MOVE [ direction { FROM | IN } ] cursor; + +stmt_move + : MOVE opt_fetch_direction cursor_variable SEMI + ; + +stmt_close + : CLOSE cursor_variable SEMI + ; + +stmt_null + : NULL_P SEMI + ; + +stmt_commit + : COMMIT plsql_opt_transaction_chain SEMI + ; + +stmt_rollback + : ROLLBACK plsql_opt_transaction_chain SEMI + ; + +plsql_opt_transaction_chain + : AND NO? CHAIN + | + ; + +stmt_set + : SET any_name TO DEFAULT SEMI + | RESET (any_name | ALL) SEMI + ; + +cursor_variable + : colid + | PARAM + ; + +exception_sect + : + | EXCEPTION proc_exceptions + ; + +proc_exceptions + : proc_exception+ + ; + +proc_exception + : WHEN proc_conditions THEN proc_sect + ; + +proc_conditions + : proc_condition (OR proc_condition)* + ; + +proc_condition + : any_identifier + | SQLSTATE sconst + ; + //expr_until_semi: + + //; + + //expr_until_rightbracket: + + //; + + //expr_until_loop: + + //; + +opt_block_label + : + | label_decl + ; + +opt_loop_label + : + | label_decl + ; + +opt_label + : + | any_identifier + ; + +opt_exitcond + : WHEN expr_until_semi + | + ; + +any_identifier + : colid + | plsql_unreserved_keyword + ; + +plsql_unreserved_keyword + : ABSOLUTE_P + | ALIAS + | AND + | ARRAY + | ASSERT + | BACKWARD + | CALL + | CHAIN + | CLOSE + | COLLATE + | COLUMN + //| COLUMN_NAME + | COMMIT + | CONSTANT + | CONSTRAINT + //| CONSTRAINT_NAME + | CONTINUE_P + | CURRENT_P + | CURSOR + //| DATATYPE + | DEBUG + | DEFAULT + //| DETAIL + | DIAGNOSTICS + | DO + | DUMP + | ELSIF + //| ERRCODE + | ERROR + | EXCEPTION + | EXIT + | FETCH + | FIRST_P + | FORWARD + | GET + //| HINT + + //| IMPORT + | INFO + | INSERT + | IS + | LAST_P + | LOG + //| MESSAGE + + //| MESSAGE_TEXT + | MOVE + | NEXT + | NO + | NOTICE + | OPEN + | OPTION + | PERFORM + //| PG_CONTEXT + + //| PG_DATATYPE_NAME + + //| PG_EXCEPTION_CONTEXT + + //| PG_EXCEPTION_DETAIL + + //| PG_EXCEPTION_HINT + | PRINT_STRICT_PARAMS + | PRIOR + | QUERY + | RAISE + | RELATIVE_P + | RESET + | RETURN + //| RETURNED_SQLSTATE + | REVERSE + | ROLLBACK + //| ROW_COUNT + | ROWTYPE + | SCHEMA + //| SCHEMA_NAME + | SCROLL + | SET + | SLICE + | SQLSTATE + | STACKED + | TABLE + //| TABLE_NAME + | TYPE_P + | USE_COLUMN + | USE_VARIABLE + | VARIABLE_CONFLICT + | WARNING + | OUTER_P + ; + +sql_expression + : opt_target_list into_clause from_clause where_clause group_clause having_clause window_clause + ; + +expr_until_then + : sql_expression + ; + +expr_until_semi + : sql_expression + ; + +expr_until_rightbracket + : a_expr + ; + +expr_until_loop + : a_expr + ; + +make_execsql_stmt + : stmt opt_returning_clause_into + ; + +opt_returning_clause_into + : INTO opt_strict into_target + | + ; + diff --git a/src/lib/pgsql/PostgreSQLLexer.interp b/src/lib/pgsql/PostgreSQLLexer.interp new file mode 100644 index 0000000..58caedb --- /dev/null +++ b/src/lib/pgsql/PostgreSQLLexer.interp @@ -0,0 +1,1702 @@ +token literal names: +null +'$' +'(' +')' +'[' +']' +',' +';' +':' +'*' +'=' +'.' +'+' +'-' +'/' +'^' +'<' +'>' +'<<' +'>>' +':=' +'<=' +'=>' +'>=' +'..' +'<>' +'::' +'%' +null +null +'ALL' +'ANALYSE' +'ANALYZE' +'AND' +'ANY' +'ARRAY' +'AS' +'ASC' +'ASYMMETRIC' +'BOTH' +'CASE' +'CAST' +'CHECK' +'COLLATE' +'COLUMN' +'CONSTRAINT' +'CREATE' +'CURRENT_CATALOG' +'CURRENT_DATE' +'CURRENT_ROLE' +'CURRENT_TIME' +'CURRENT_TIMESTAMP' +'CURRENT_USER' +'DEFAULT' +'DEFERRABLE' +'DESC' +'DISTINCT' +'DO' +'ELSE' +'EXCEPT' +'FALSE' +'FETCH' +'FOR' +'FOREIGN' +'FROM' +'GRANT' +'GROUP' +'HAVING' +'IN' +'INITIALLY' +'INTERSECT' +'INTO' +'LATERAL' +'LEADING' +'LIMIT' +'LOCALTIME' +'LOCALTIMESTAMP' +'NOT' +'NULL' +'OFFSET' +'ON' +'ONLY' +'OR' +'ORDER' +'PLACING' +'PRIMARY' +'REFERENCES' +'RETURNING' +'SELECT' +'SESSION_USER' +'SOME' +'SYMMETRIC' +'TABLE' +'THEN' +'TO' +'TRAILING' +'TRUE' +'UNION' +'UNIQUE' +'USER' +'USING' +'VARIADIC' +'WHEN' +'WHERE' +'WINDOW' +'WITH' +'AUTHORIZATION' +'BINARY' +'COLLATION' +'CONCURRENTLY' +'CROSS' +'CURRENT_SCHEMA' +'FREEZE' +'FULL' +'ILIKE' +'INNER' +'IS' +'ISNULL' +'JOIN' +'LEFT' +'LIKE' +'NATURAL' +'NOTNULL' +'OUTER' +'OVER' +'OVERLAPS' +'RIGHT' +'SIMILAR' +'VERBOSE' +'ABORT' +'ABSOLUTE' +'ACCESS' +'ACTION' +'ADD' +'ADMIN' +'AFTER' +'AGGREGATE' +'ALSO' +'ALTER' +'ALWAYS' +'ASSERTION' +'ASSIGNMENT' +'AT' +'ATTRIBUTE' +'BACKWARD' +'BEFORE' +'BEGIN' +'BY' +'CACHE' +'CALLED' +'CASCADE' +'CASCADED' +'CATALOG' +'CHAIN' +'CHARACTERISTICS' +'CHECKPOINT' +'CLASS' +'CLOSE' +'CLUSTER' +'COMMENT' +'COMMENTS' +'COMMIT' +'COMMITTED' +'CONFIGURATION' +'CONNECTION' +'CONSTRAINTS' +'CONTENT' +'CONTINUE' +'CONVERSION' +'COPY' +'COST' +'CSV' +'CURSOR' +'CYCLE' +'DATA' +'DATABASE' +'DAY' +'DEALLOCATE' +'DECLARE' +'DEFAULTS' +'DEFERRED' +'DEFINER' +'DELETE' +'DELIMITER' +'DELIMITERS' +'DICTIONARY' +'DISABLE' +'DISCARD' +'DOCUMENT' +'DOMAIN' +'DOUBLE' +'DROP' +'EACH' +'ENABLE' +'ENCODING' +'ENCRYPTED' +'ENUM' +'ESCAPE' +'EVENT' +'EXCLUDE' +'EXCLUDING' +'EXCLUSIVE' +'EXECUTE' +'EXPLAIN' +'EXTENSION' +'EXTERNAL' +'FAMILY' +'FIRST' +'FOLLOWING' +'FORCE' +'FORWARD' +'FUNCTION' +'FUNCTIONS' +'GLOBAL' +'GRANTED' +'HANDLER' +'HEADER' +'HOLD' +'HOUR' +'IDENTITY' +'IF' +'IMMEDIATE' +'IMMUTABLE' +'IMPLICIT' +'INCLUDING' +'INCREMENT' +'INDEX' +'INDEXES' +'INHERIT' +'INHERITS' +'INLINE' +'INSENSITIVE' +'INSERT' +'INSTEAD' +'INVOKER' +'ISOLATION' +'KEY' +'LABEL' +'LANGUAGE' +'LARGE' +'LAST' +'LEAKPROOF' +'LEVEL' +'LISTEN' +'LOAD' +'LOCAL' +'LOCATION' +'LOCK' +'MAPPING' +'MATCH' +'MATERIALIZED' +'MAXVALUE' +'MINUTE' +'MINVALUE' +'MODE' +'MONTH' +'MOVE' +'NAME' +'NAMES' +'NEXT' +'NO' +'NOTHING' +'NOTIFY' +'NOWAIT' +'NULLS' +'OBJECT' +'OF' +'OFF' +'OIDS' +'OPERATOR' +'OPTION' +'OPTIONS' +'OWNED' +'OWNER' +'PARSER' +'PARTIAL' +'PARTITION' +'PASSING' +'PASSWORD' +'PLANS' +'PRECEDING' +'PREPARE' +'PREPARED' +'PRESERVE' +'PRIOR' +'PRIVILEGES' +'PROCEDURAL' +'PROCEDURE' +'PROGRAM' +'QUOTE' +'RANGE' +'READ' +'REASSIGN' +'RECHECK' +'RECURSIVE' +'REF' +'REFRESH' +'REINDEX' +'RELATIVE' +'RELEASE' +'RENAME' +'REPEATABLE' +'REPLACE' +'REPLICA' +'RESET' +'RESTART' +'RESTRICT' +'RETURNS' +'REVOKE' +'ROLE' +'ROLLBACK' +'ROWS' +'RULE' +'SAVEPOINT' +'SCHEMA' +'SCROLL' +'SEARCH' +'SECOND' +'SECURITY' +'SEQUENCE' +'SEQUENCES' +'SERIALIZABLE' +'SERVER' +'SESSION' +'SET' +'SHARE' +'SHOW' +'SIMPLE' +'SNAPSHOT' +'STABLE' +'STANDALONE' +'START' +'STATEMENT' +'STATISTICS' +'STDIN' +'STDOUT' +'STORAGE' +'STRICT' +'STRIP' +'SYSID' +'SYSTEM' +'TABLES' +'TABLESPACE' +'TEMP' +'TEMPLATE' +'TEMPORARY' +'TEXT' +'TRANSACTION' +'TRIGGER' +'TRUNCATE' +'TRUSTED' +'TYPE' +'TYPES' +'UNBOUNDED' +'UNCOMMITTED' +'UNENCRYPTED' +'UNKNOWN' +'UNLISTEN' +'UNLOGGED' +'UNTIL' +'UPDATE' +'VACUUM' +'VALID' +'VALIDATE' +'VALIDATOR' +'VARYING' +'VERSION' +'VIEW' +'VOLATILE' +'WHITESPACE' +'WITHOUT' +'WORK' +'WRAPPER' +'WRITE' +'XML' +'YEAR' +'YES' +'ZONE' +'BETWEEN' +'BIGINT' +'BIT' +'BOOLEAN' +'CHAR' +'CHARACTER' +'COALESCE' +'DEC' +'DECIMAL' +'EXISTS' +'EXTRACT' +'FLOAT' +'GREATEST' +'INOUT' +'INT' +'INTEGER' +'INTERVAL' +'LEAST' +'NATIONAL' +'NCHAR' +'NONE' +'NULLIF' +'NUMERIC' +'OVERLAY' +'POSITION' +'PRECISION' +'REAL' +'ROW' +'SETOF' +'SMALLINT' +'SUBSTRING' +'TIME' +'TIMESTAMP' +'TREAT' +'TRIM' +'VALUES' +'VARCHAR' +'XMLATTRIBUTES' +'XMLCONCAT' +'XMLELEMENT' +'XMLEXISTS' +'XMLFOREST' +'XMLPARSE' +'XMLPI' +'XMLROOT' +'XMLSERIALIZE' +'CALL' +'CURRENT' +'ATTACH' +'DETACH' +'EXPRESSION' +'GENERATED' +'LOGGED' +'STORED' +'INCLUDE' +'ROUTINE' +'TRANSFORM' +'IMPORT' +'POLICY' +'METHOD' +'REFERENCING' +'NEW' +'OLD' +'VALUE' +'SUBSCRIPTION' +'PUBLICATION' +'OUT' +'END' +'ROUTINES' +'SCHEMAS' +'PROCEDURES' +'INPUT' +'SUPPORT' +'PARALLEL' +'SQL' +'DEPENDS' +'OVERRIDING' +'CONFLICT' +'SKIP' +'LOCKED' +'TIES' +'ROLLUP' +'CUBE' +'GROUPING' +'SETS' +'TABLESAMPLE' +'ORDINALITY' +'XMLTABLE' +'COLUMNS' +'XMLNAMESPACES' +'ROWTYPE' +'NORMALIZED' +'WITHIN' +'FILTER' +'GROUPS' +'OTHERS' +'NFC' +'NFD' +'NFKC' +'NFKD' +'UESCAPE' +'VIEWS' +'NORMALIZE' +'DUMP' +'PRINT_STRICT_PARAMS' +'VARIABLE_CONFLICT' +'ERROR' +'USE_VARIABLE' +'USE_COLUMN' +'ALIAS' +'CONSTANT' +'PERFORM' +'GET' +'DIAGNOSTICS' +'STACKED' +'ELSIF' +'WHILE' +'REVERSE' +'FOREACH' +'SLICE' +'EXIT' +'RETURN' +'QUERY' +'RAISE' +'SQLSTATE' +'DEBUG' +'LOG' +'INFO' +'NOTICE' +'WARNING' +'EXCEPTION' +'ASSERT' +'LOOP' +'OPEN' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'\\\\' +null +null +null +null +null +null +null +null +null +'\'' + +token symbolic names: +null +Dollar +OPEN_PAREN +CLOSE_PAREN +OPEN_BRACKET +CLOSE_BRACKET +COMMA +SEMI +COLON +STAR +EQUAL +DOT +PLUS +MINUS +SLASH +CARET +LT +GT +LESS_LESS +GREATER_GREATER +COLON_EQUALS +LESS_EQUALS +EQUALS_GREATER +GREATER_EQUALS +DOT_DOT +NOT_EQUALS +TYPECAST +PERCENT +PARAM +Operator +ALL +ANALYSE +ANALYZE +AND +ANY +ARRAY +AS +ASC +ASYMMETRIC +BOTH +CASE +CAST +CHECK +COLLATE +COLUMN +CONSTRAINT +CREATE +CURRENT_CATALOG +CURRENT_DATE +CURRENT_ROLE +CURRENT_TIME +CURRENT_TIMESTAMP +CURRENT_USER +DEFAULT +DEFERRABLE +DESC +DISTINCT +DO +ELSE +EXCEPT +FALSE_P +FETCH +FOR +FOREIGN +FROM +GRANT +GROUP_P +HAVING +IN_P +INITIALLY +INTERSECT +INTO +LATERAL_P +LEADING +LIMIT +LOCALTIME +LOCALTIMESTAMP +NOT +NULL_P +OFFSET +ON +ONLY +OR +ORDER +PLACING +PRIMARY +REFERENCES +RETURNING +SELECT +SESSION_USER +SOME +SYMMETRIC +TABLE +THEN +TO +TRAILING +TRUE_P +UNION +UNIQUE +USER +USING +VARIADIC +WHEN +WHERE +WINDOW +WITH +AUTHORIZATION +BINARY +COLLATION +CONCURRENTLY +CROSS +CURRENT_SCHEMA +FREEZE +FULL +ILIKE +INNER_P +IS +ISNULL +JOIN +LEFT +LIKE +NATURAL +NOTNULL +OUTER_P +OVER +OVERLAPS +RIGHT +SIMILAR +VERBOSE +ABORT_P +ABSOLUTE_P +ACCESS +ACTION +ADD_P +ADMIN +AFTER +AGGREGATE +ALSO +ALTER +ALWAYS +ASSERTION +ASSIGNMENT +AT +ATTRIBUTE +BACKWARD +BEFORE +BEGIN_P +BY +CACHE +CALLED +CASCADE +CASCADED +CATALOG +CHAIN +CHARACTERISTICS +CHECKPOINT +CLASS +CLOSE +CLUSTER +COMMENT +COMMENTS +COMMIT +COMMITTED +CONFIGURATION +CONNECTION +CONSTRAINTS +CONTENT_P +CONTINUE_P +CONVERSION_P +COPY +COST +CSV +CURSOR +CYCLE +DATA_P +DATABASE +DAY_P +DEALLOCATE +DECLARE +DEFAULTS +DEFERRED +DEFINER +DELETE_P +DELIMITER +DELIMITERS +DICTIONARY +DISABLE_P +DISCARD +DOCUMENT_P +DOMAIN_P +DOUBLE_P +DROP +EACH +ENABLE_P +ENCODING +ENCRYPTED +ENUM_P +ESCAPE +EVENT +EXCLUDE +EXCLUDING +EXCLUSIVE +EXECUTE +EXPLAIN +EXTENSION +EXTERNAL +FAMILY +FIRST_P +FOLLOWING +FORCE +FORWARD +FUNCTION +FUNCTIONS +GLOBAL +GRANTED +HANDLER +HEADER_P +HOLD +HOUR_P +IDENTITY_P +IF_P +IMMEDIATE +IMMUTABLE +IMPLICIT_P +INCLUDING +INCREMENT +INDEX +INDEXES +INHERIT +INHERITS +INLINE_P +INSENSITIVE +INSERT +INSTEAD +INVOKER +ISOLATION +KEY +LABEL +LANGUAGE +LARGE_P +LAST_P +LEAKPROOF +LEVEL +LISTEN +LOAD +LOCAL +LOCATION +LOCK_P +MAPPING +MATCH +MATERIALIZED +MAXVALUE +MINUTE_P +MINVALUE +MODE +MONTH_P +MOVE +NAME_P +NAMES +NEXT +NO +NOTHING +NOTIFY +NOWAIT +NULLS_P +OBJECT_P +OF +OFF +OIDS +OPERATOR +OPTION +OPTIONS +OWNED +OWNER +PARSER +PARTIAL +PARTITION +PASSING +PASSWORD +PLANS +PRECEDING +PREPARE +PREPARED +PRESERVE +PRIOR +PRIVILEGES +PROCEDURAL +PROCEDURE +PROGRAM +QUOTE +RANGE +READ +REASSIGN +RECHECK +RECURSIVE +REF +REFRESH +REINDEX +RELATIVE_P +RELEASE +RENAME +REPEATABLE +REPLACE +REPLICA +RESET +RESTART +RESTRICT +RETURNS +REVOKE +ROLE +ROLLBACK +ROWS +RULE +SAVEPOINT +SCHEMA +SCROLL +SEARCH +SECOND_P +SECURITY +SEQUENCE +SEQUENCES +SERIALIZABLE +SERVER +SESSION +SET +SHARE +SHOW +SIMPLE +SNAPSHOT +STABLE +STANDALONE_P +START +STATEMENT +STATISTICS +STDIN +STDOUT +STORAGE +STRICT_P +STRIP_P +SYSID +SYSTEM_P +TABLES +TABLESPACE +TEMP +TEMPLATE +TEMPORARY +TEXT_P +TRANSACTION +TRIGGER +TRUNCATE +TRUSTED +TYPE_P +TYPES_P +UNBOUNDED +UNCOMMITTED +UNENCRYPTED +UNKNOWN +UNLISTEN +UNLOGGED +UNTIL +UPDATE +VACUUM +VALID +VALIDATE +VALIDATOR +VARYING +VERSION_P +VIEW +VOLATILE +WHITESPACE_P +WITHOUT +WORK +WRAPPER +WRITE +XML_P +YEAR_P +YES_P +ZONE +BETWEEN +BIGINT +BIT +BOOLEAN_P +CHAR_P +CHARACTER +COALESCE +DEC +DECIMAL_P +EXISTS +EXTRACT +FLOAT_P +GREATEST +INOUT +INT_P +INTEGER +INTERVAL +LEAST +NATIONAL +NCHAR +NONE +NULLIF +NUMERIC +OVERLAY +POSITION +PRECISION +REAL +ROW +SETOF +SMALLINT +SUBSTRING +TIME +TIMESTAMP +TREAT +TRIM +VALUES +VARCHAR +XMLATTRIBUTES +XMLCONCAT +XMLELEMENT +XMLEXISTS +XMLFOREST +XMLPARSE +XMLPI +XMLROOT +XMLSERIALIZE +CALL +CURRENT_P +ATTACH +DETACH +EXPRESSION +GENERATED +LOGGED +STORED +INCLUDE +ROUTINE +TRANSFORM +IMPORT_P +POLICY +METHOD +REFERENCING +NEW +OLD +VALUE_P +SUBSCRIPTION +PUBLICATION +OUT_P +END_P +ROUTINES +SCHEMAS +PROCEDURES +INPUT_P +SUPPORT +PARALLEL +SQL_P +DEPENDS +OVERRIDING +CONFLICT +SKIP_P +LOCKED +TIES +ROLLUP +CUBE +GROUPING +SETS +TABLESAMPLE +ORDINALITY +XMLTABLE +COLUMNS +XMLNAMESPACES +ROWTYPE +NORMALIZED +WITHIN +FILTER +GROUPS +OTHERS +NFC +NFD +NFKC +NFKD +UESCAPE +VIEWS +NORMALIZE +DUMP +PRINT_STRICT_PARAMS +VARIABLE_CONFLICT +ERROR +USE_VARIABLE +USE_COLUMN +ALIAS +CONSTANT +PERFORM +GET +DIAGNOSTICS +STACKED +ELSIF +WHILE +REVERSE +FOREACH +SLICE +EXIT +RETURN +QUERY +RAISE +SQLSTATE +DEBUG +LOG +INFO +NOTICE +WARNING +EXCEPTION +ASSERT +LOOP +OPEN +Identifier +QuotedIdentifier +UnterminatedQuotedIdentifier +InvalidQuotedIdentifier +InvalidUnterminatedQuotedIdentifier +UnicodeQuotedIdentifier +UnterminatedUnicodeQuotedIdentifier +InvalidUnicodeQuotedIdentifier +InvalidUnterminatedUnicodeQuotedIdentifier +StringConstant +UnterminatedStringConstant +UnicodeEscapeStringConstant +UnterminatedUnicodeEscapeStringConstant +BeginDollarStringConstant +BinaryStringConstant +UnterminatedBinaryStringConstant +InvalidBinaryStringConstant +InvalidUnterminatedBinaryStringConstant +HexadecimalStringConstant +UnterminatedHexadecimalStringConstant +InvalidHexadecimalStringConstant +InvalidUnterminatedHexadecimalStringConstant +Integral +NumericFail +Numeric +PLSQLVARIABLENAME +PLSQLIDENTIFIER +Whitespace +Newline +LineComment +BlockComment +UnterminatedBlockComment +MetaCommand +EndMetaCommand +ErrorCharacter +EscapeStringConstant +UnterminatedEscapeStringConstant +InvalidEscapeStringConstant +InvalidUnterminatedEscapeStringConstant +AfterEscapeStringConstantMode_NotContinued +AfterEscapeStringConstantWithNewlineMode_NotContinued +DollarText +EndDollarStringConstant +AfterEscapeStringConstantWithNewlineMode_Continued + +rule names: +Dollar +OPEN_PAREN +CLOSE_PAREN +OPEN_BRACKET +CLOSE_BRACKET +COMMA +SEMI +COLON +STAR +EQUAL +DOT +PLUS +MINUS +SLASH +CARET +LT +GT +LESS_LESS +GREATER_GREATER +COLON_EQUALS +LESS_EQUALS +EQUALS_GREATER +GREATER_EQUALS +DOT_DOT +NOT_EQUALS +TYPECAST +PERCENT +PARAM +Operator +OperatorEndingWithPlusMinus +OperatorCharacter +OperatorCharacterNotAllowPlusMinusAtEnd +OperatorCharacterAllowPlusMinusAtEnd +ALL +ANALYSE +ANALYZE +AND +ANY +ARRAY +AS +ASC +ASYMMETRIC +BOTH +CASE +CAST +CHECK +COLLATE +COLUMN +CONSTRAINT +CREATE +CURRENT_CATALOG +CURRENT_DATE +CURRENT_ROLE +CURRENT_TIME +CURRENT_TIMESTAMP +CURRENT_USER +DEFAULT +DEFERRABLE +DESC +DISTINCT +DO +ELSE +EXCEPT +FALSE_P +FETCH +FOR +FOREIGN +FROM +GRANT +GROUP_P +HAVING +IN_P +INITIALLY +INTERSECT +INTO +LATERAL_P +LEADING +LIMIT +LOCALTIME +LOCALTIMESTAMP +NOT +NULL_P +OFFSET +ON +ONLY +OR +ORDER +PLACING +PRIMARY +REFERENCES +RETURNING +SELECT +SESSION_USER +SOME +SYMMETRIC +TABLE +THEN +TO +TRAILING +TRUE_P +UNION +UNIQUE +USER +USING +VARIADIC +WHEN +WHERE +WINDOW +WITH +AUTHORIZATION +BINARY +COLLATION +CONCURRENTLY +CROSS +CURRENT_SCHEMA +FREEZE +FULL +ILIKE +INNER_P +IS +ISNULL +JOIN +LEFT +LIKE +NATURAL +NOTNULL +OUTER_P +OVER +OVERLAPS +RIGHT +SIMILAR +VERBOSE +ABORT_P +ABSOLUTE_P +ACCESS +ACTION +ADD_P +ADMIN +AFTER +AGGREGATE +ALSO +ALTER +ALWAYS +ASSERTION +ASSIGNMENT +AT +ATTRIBUTE +BACKWARD +BEFORE +BEGIN_P +BY +CACHE +CALLED +CASCADE +CASCADED +CATALOG +CHAIN +CHARACTERISTICS +CHECKPOINT +CLASS +CLOSE +CLUSTER +COMMENT +COMMENTS +COMMIT +COMMITTED +CONFIGURATION +CONNECTION +CONSTRAINTS +CONTENT_P +CONTINUE_P +CONVERSION_P +COPY +COST +CSV +CURSOR +CYCLE +DATA_P +DATABASE +DAY_P +DEALLOCATE +DECLARE +DEFAULTS +DEFERRED +DEFINER +DELETE_P +DELIMITER +DELIMITERS +DICTIONARY +DISABLE_P +DISCARD +DOCUMENT_P +DOMAIN_P +DOUBLE_P +DROP +EACH +ENABLE_P +ENCODING +ENCRYPTED +ENUM_P +ESCAPE +EVENT +EXCLUDE +EXCLUDING +EXCLUSIVE +EXECUTE +EXPLAIN +EXTENSION +EXTERNAL +FAMILY +FIRST_P +FOLLOWING +FORCE +FORWARD +FUNCTION +FUNCTIONS +GLOBAL +GRANTED +HANDLER +HEADER_P +HOLD +HOUR_P +IDENTITY_P +IF_P +IMMEDIATE +IMMUTABLE +IMPLICIT_P +INCLUDING +INCREMENT +INDEX +INDEXES +INHERIT +INHERITS +INLINE_P +INSENSITIVE +INSERT +INSTEAD +INVOKER +ISOLATION +KEY +LABEL +LANGUAGE +LARGE_P +LAST_P +LEAKPROOF +LEVEL +LISTEN +LOAD +LOCAL +LOCATION +LOCK_P +MAPPING +MATCH +MATERIALIZED +MAXVALUE +MINUTE_P +MINVALUE +MODE +MONTH_P +MOVE +NAME_P +NAMES +NEXT +NO +NOTHING +NOTIFY +NOWAIT +NULLS_P +OBJECT_P +OF +OFF +OIDS +OPERATOR +OPTION +OPTIONS +OWNED +OWNER +PARSER +PARTIAL +PARTITION +PASSING +PASSWORD +PLANS +PRECEDING +PREPARE +PREPARED +PRESERVE +PRIOR +PRIVILEGES +PROCEDURAL +PROCEDURE +PROGRAM +QUOTE +RANGE +READ +REASSIGN +RECHECK +RECURSIVE +REF +REFRESH +REINDEX +RELATIVE_P +RELEASE +RENAME +REPEATABLE +REPLACE +REPLICA +RESET +RESTART +RESTRICT +RETURNS +REVOKE +ROLE +ROLLBACK +ROWS +RULE +SAVEPOINT +SCHEMA +SCROLL +SEARCH +SECOND_P +SECURITY +SEQUENCE +SEQUENCES +SERIALIZABLE +SERVER +SESSION +SET +SHARE +SHOW +SIMPLE +SNAPSHOT +STABLE +STANDALONE_P +START +STATEMENT +STATISTICS +STDIN +STDOUT +STORAGE +STRICT_P +STRIP_P +SYSID +SYSTEM_P +TABLES +TABLESPACE +TEMP +TEMPLATE +TEMPORARY +TEXT_P +TRANSACTION +TRIGGER +TRUNCATE +TRUSTED +TYPE_P +TYPES_P +UNBOUNDED +UNCOMMITTED +UNENCRYPTED +UNKNOWN +UNLISTEN +UNLOGGED +UNTIL +UPDATE +VACUUM +VALID +VALIDATE +VALIDATOR +VARYING +VERSION_P +VIEW +VOLATILE +WHITESPACE_P +WITHOUT +WORK +WRAPPER +WRITE +XML_P +YEAR_P +YES_P +ZONE +BETWEEN +BIGINT +BIT +BOOLEAN_P +CHAR_P +CHARACTER +COALESCE +DEC +DECIMAL_P +EXISTS +EXTRACT +FLOAT_P +GREATEST +INOUT +INT_P +INTEGER +INTERVAL +LEAST +NATIONAL +NCHAR +NONE +NULLIF +NUMERIC +OVERLAY +POSITION +PRECISION +REAL +ROW +SETOF +SMALLINT +SUBSTRING +TIME +TIMESTAMP +TREAT +TRIM +VALUES +VARCHAR +XMLATTRIBUTES +XMLCONCAT +XMLELEMENT +XMLEXISTS +XMLFOREST +XMLPARSE +XMLPI +XMLROOT +XMLSERIALIZE +CALL +CURRENT_P +ATTACH +DETACH +EXPRESSION +GENERATED +LOGGED +STORED +INCLUDE +ROUTINE +TRANSFORM +IMPORT_P +POLICY +METHOD +REFERENCING +NEW +OLD +VALUE_P +SUBSCRIPTION +PUBLICATION +OUT_P +END_P +ROUTINES +SCHEMAS +PROCEDURES +INPUT_P +SUPPORT +PARALLEL +SQL_P +DEPENDS +OVERRIDING +CONFLICT +SKIP_P +LOCKED +TIES +ROLLUP +CUBE +GROUPING +SETS +TABLESAMPLE +ORDINALITY +XMLTABLE +COLUMNS +XMLNAMESPACES +ROWTYPE +NORMALIZED +WITHIN +FILTER +GROUPS +OTHERS +NFC +NFD +NFKC +NFKD +UESCAPE +VIEWS +NORMALIZE +DUMP +PRINT_STRICT_PARAMS +VARIABLE_CONFLICT +ERROR +USE_VARIABLE +USE_COLUMN +ALIAS +CONSTANT +PERFORM +GET +DIAGNOSTICS +STACKED +ELSIF +WHILE +REVERSE +FOREACH +SLICE +EXIT +RETURN +QUERY +RAISE +SQLSTATE +DEBUG +LOG +INFO +NOTICE +WARNING +EXCEPTION +ASSERT +LOOP +OPEN +Identifier +IdentifierStartChar +IdentifierChar +StrictIdentifierChar +QuotedIdentifier +UnterminatedQuotedIdentifier +InvalidQuotedIdentifier +InvalidUnterminatedQuotedIdentifier +UnicodeQuotedIdentifier +UnterminatedUnicodeQuotedIdentifier +InvalidUnicodeQuotedIdentifier +InvalidUnterminatedUnicodeQuotedIdentifier +StringConstant +UnterminatedStringConstant +BeginEscapeStringConstant +UnicodeEscapeStringConstant +UnterminatedUnicodeEscapeStringConstant +BeginDollarStringConstant +Tag +BinaryStringConstant +UnterminatedBinaryStringConstant +InvalidBinaryStringConstant +InvalidUnterminatedBinaryStringConstant +HexadecimalStringConstant +UnterminatedHexadecimalStringConstant +InvalidHexadecimalStringConstant +InvalidUnterminatedHexadecimalStringConstant +Integral +NumericFail +Numeric +Digits +PLSQLVARIABLENAME +PLSQLIDENTIFIER +Whitespace +Newline +LineComment +BlockComment +UnterminatedBlockComment +MetaCommand +EndMetaCommand +ErrorCharacter +EscapeStringConstant +UnterminatedEscapeStringConstant +EscapeStringText +InvalidEscapeStringConstant +InvalidUnterminatedEscapeStringConstant +InvalidEscapeStringText +AfterEscapeStringConstantMode_Whitespace +AfterEscapeStringConstantMode_Newline +AfterEscapeStringConstantMode_NotContinued +AfterEscapeStringConstantWithNewlineMode_Whitespace +AfterEscapeStringConstantWithNewlineMode_Newline +AfterEscapeStringConstantWithNewlineMode_Continued +AfterEscapeStringConstantWithNewlineMode_NotContinued +DollarText +EndDollarStringConstant + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE +EscapeStringConstantMode +AfterEscapeStringConstantMode +AfterEscapeStringConstantWithNewlineMode +DollarQuotedStringMode + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 557, 5406, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174, 9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178, 4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183, 9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187, 4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 4, 191, 9, 191, 4, 192, 9, 192, 4, 193, 9, 193, 4, 194, 9, 194, 4, 195, 9, 195, 4, 196, 9, 196, 4, 197, 9, 197, 4, 198, 9, 198, 4, 199, 9, 199, 4, 200, 9, 200, 4, 201, 9, 201, 4, 202, 9, 202, 4, 203, 9, 203, 4, 204, 9, 204, 4, 205, 9, 205, 4, 206, 9, 206, 4, 207, 9, 207, 4, 208, 9, 208, 4, 209, 9, 209, 4, 210, 9, 210, 4, 211, 9, 211, 4, 212, 9, 212, 4, 213, 9, 213, 4, 214, 9, 214, 4, 215, 9, 215, 4, 216, 9, 216, 4, 217, 9, 217, 4, 218, 9, 218, 4, 219, 9, 219, 4, 220, 9, 220, 4, 221, 9, 221, 4, 222, 9, 222, 4, 223, 9, 223, 4, 224, 9, 224, 4, 225, 9, 225, 4, 226, 9, 226, 4, 227, 9, 227, 4, 228, 9, 228, 4, 229, 9, 229, 4, 230, 9, 230, 4, 231, 9, 231, 4, 232, 9, 232, 4, 233, 9, 233, 4, 234, 9, 234, 4, 235, 9, 235, 4, 236, 9, 236, 4, 237, 9, 237, 4, 238, 9, 238, 4, 239, 9, 239, 4, 240, 9, 240, 4, 241, 9, 241, 4, 242, 9, 242, 4, 243, 9, 243, 4, 244, 9, 244, 4, 245, 9, 245, 4, 246, 9, 246, 4, 247, 9, 247, 4, 248, 9, 248, 4, 249, 9, 249, 4, 250, 9, 250, 4, 251, 9, 251, 4, 252, 9, 252, 4, 253, 9, 253, 4, 254, 9, 254, 4, 255, 9, 255, 4, 256, 9, 256, 4, 257, 9, 257, 4, 258, 9, 258, 4, 259, 9, 259, 4, 260, 9, 260, 4, 261, 9, 261, 4, 262, 9, 262, 4, 263, 9, 263, 4, 264, 9, 264, 4, 265, 9, 265, 4, 266, 9, 266, 4, 267, 9, 267, 4, 268, 9, 268, 4, 269, 9, 269, 4, 270, 9, 270, 4, 271, 9, 271, 4, 272, 9, 272, 4, 273, 9, 273, 4, 274, 9, 274, 4, 275, 9, 275, 4, 276, 9, 276, 4, 277, 9, 277, 4, 278, 9, 278, 4, 279, 9, 279, 4, 280, 9, 280, 4, 281, 9, 281, 4, 282, 9, 282, 4, 283, 9, 283, 4, 284, 9, 284, 4, 285, 9, 285, 4, 286, 9, 286, 4, 287, 9, 287, 4, 288, 9, 288, 4, 289, 9, 289, 4, 290, 9, 290, 4, 291, 9, 291, 4, 292, 9, 292, 4, 293, 9, 293, 4, 294, 9, 294, 4, 295, 9, 295, 4, 296, 9, 296, 4, 297, 9, 297, 4, 298, 9, 298, 4, 299, 9, 299, 4, 300, 9, 300, 4, 301, 9, 301, 4, 302, 9, 302, 4, 303, 9, 303, 4, 304, 9, 304, 4, 305, 9, 305, 4, 306, 9, 306, 4, 307, 9, 307, 4, 308, 9, 308, 4, 309, 9, 309, 4, 310, 9, 310, 4, 311, 9, 311, 4, 312, 9, 312, 4, 313, 9, 313, 4, 314, 9, 314, 4, 315, 9, 315, 4, 316, 9, 316, 4, 317, 9, 317, 4, 318, 9, 318, 4, 319, 9, 319, 4, 320, 9, 320, 4, 321, 9, 321, 4, 322, 9, 322, 4, 323, 9, 323, 4, 324, 9, 324, 4, 325, 9, 325, 4, 326, 9, 326, 4, 327, 9, 327, 4, 328, 9, 328, 4, 329, 9, 329, 4, 330, 9, 330, 4, 331, 9, 331, 4, 332, 9, 332, 4, 333, 9, 333, 4, 334, 9, 334, 4, 335, 9, 335, 4, 336, 9, 336, 4, 337, 9, 337, 4, 338, 9, 338, 4, 339, 9, 339, 4, 340, 9, 340, 4, 341, 9, 341, 4, 342, 9, 342, 4, 343, 9, 343, 4, 344, 9, 344, 4, 345, 9, 345, 4, 346, 9, 346, 4, 347, 9, 347, 4, 348, 9, 348, 4, 349, 9, 349, 4, 350, 9, 350, 4, 351, 9, 351, 4, 352, 9, 352, 4, 353, 9, 353, 4, 354, 9, 354, 4, 355, 9, 355, 4, 356, 9, 356, 4, 357, 9, 357, 4, 358, 9, 358, 4, 359, 9, 359, 4, 360, 9, 360, 4, 361, 9, 361, 4, 362, 9, 362, 4, 363, 9, 363, 4, 364, 9, 364, 4, 365, 9, 365, 4, 366, 9, 366, 4, 367, 9, 367, 4, 368, 9, 368, 4, 369, 9, 369, 4, 370, 9, 370, 4, 371, 9, 371, 4, 372, 9, 372, 4, 373, 9, 373, 4, 374, 9, 374, 4, 375, 9, 375, 4, 376, 9, 376, 4, 377, 9, 377, 4, 378, 9, 378, 4, 379, 9, 379, 4, 380, 9, 380, 4, 381, 9, 381, 4, 382, 9, 382, 4, 383, 9, 383, 4, 384, 9, 384, 4, 385, 9, 385, 4, 386, 9, 386, 4, 387, 9, 387, 4, 388, 9, 388, 4, 389, 9, 389, 4, 390, 9, 390, 4, 391, 9, 391, 4, 392, 9, 392, 4, 393, 9, 393, 4, 394, 9, 394, 4, 395, 9, 395, 4, 396, 9, 396, 4, 397, 9, 397, 4, 398, 9, 398, 4, 399, 9, 399, 4, 400, 9, 400, 4, 401, 9, 401, 4, 402, 9, 402, 4, 403, 9, 403, 4, 404, 9, 404, 4, 405, 9, 405, 4, 406, 9, 406, 4, 407, 9, 407, 4, 408, 9, 408, 4, 409, 9, 409, 4, 410, 9, 410, 4, 411, 9, 411, 4, 412, 9, 412, 4, 413, 9, 413, 4, 414, 9, 414, 4, 415, 9, 415, 4, 416, 9, 416, 4, 417, 9, 417, 4, 418, 9, 418, 4, 419, 9, 419, 4, 420, 9, 420, 4, 421, 9, 421, 4, 422, 9, 422, 4, 423, 9, 423, 4, 424, 9, 424, 4, 425, 9, 425, 4, 426, 9, 426, 4, 427, 9, 427, 4, 428, 9, 428, 4, 429, 9, 429, 4, 430, 9, 430, 4, 431, 9, 431, 4, 432, 9, 432, 4, 433, 9, 433, 4, 434, 9, 434, 4, 435, 9, 435, 4, 436, 9, 436, 4, 437, 9, 437, 4, 438, 9, 438, 4, 439, 9, 439, 4, 440, 9, 440, 4, 441, 9, 441, 4, 442, 9, 442, 4, 443, 9, 443, 4, 444, 9, 444, 4, 445, 9, 445, 4, 446, 9, 446, 4, 447, 9, 447, 4, 448, 9, 448, 4, 449, 9, 449, 4, 450, 9, 450, 4, 451, 9, 451, 4, 452, 9, 452, 4, 453, 9, 453, 4, 454, 9, 454, 4, 455, 9, 455, 4, 456, 9, 456, 4, 457, 9, 457, 4, 458, 9, 458, 4, 459, 9, 459, 4, 460, 9, 460, 4, 461, 9, 461, 4, 462, 9, 462, 4, 463, 9, 463, 4, 464, 9, 464, 4, 465, 9, 465, 4, 466, 9, 466, 4, 467, 9, 467, 4, 468, 9, 468, 4, 469, 9, 469, 4, 470, 9, 470, 4, 471, 9, 471, 4, 472, 9, 472, 4, 473, 9, 473, 4, 474, 9, 474, 4, 475, 9, 475, 4, 476, 9, 476, 4, 477, 9, 477, 4, 478, 9, 478, 4, 479, 9, 479, 4, 480, 9, 480, 4, 481, 9, 481, 4, 482, 9, 482, 4, 483, 9, 483, 4, 484, 9, 484, 4, 485, 9, 485, 4, 486, 9, 486, 4, 487, 9, 487, 4, 488, 9, 488, 4, 489, 9, 489, 4, 490, 9, 490, 4, 491, 9, 491, 4, 492, 9, 492, 4, 493, 9, 493, 4, 494, 9, 494, 4, 495, 9, 495, 4, 496, 9, 496, 4, 497, 9, 497, 4, 498, 9, 498, 4, 499, 9, 499, 4, 500, 9, 500, 4, 501, 9, 501, 4, 502, 9, 502, 4, 503, 9, 503, 4, 504, 9, 504, 4, 505, 9, 505, 4, 506, 9, 506, 4, 507, 9, 507, 4, 508, 9, 508, 4, 509, 9, 509, 4, 510, 9, 510, 4, 511, 9, 511, 4, 512, 9, 512, 4, 513, 9, 513, 4, 514, 9, 514, 4, 515, 9, 515, 4, 516, 9, 516, 4, 517, 9, 517, 4, 518, 9, 518, 4, 519, 9, 519, 4, 520, 9, 520, 4, 521, 9, 521, 4, 522, 9, 522, 4, 523, 9, 523, 4, 524, 9, 524, 4, 525, 9, 525, 4, 526, 9, 526, 4, 527, 9, 527, 4, 528, 9, 528, 4, 529, 9, 529, 4, 530, 9, 530, 4, 531, 9, 531, 4, 532, 9, 532, 4, 533, 9, 533, 4, 534, 9, 534, 4, 535, 9, 535, 4, 536, 9, 536, 4, 537, 9, 537, 4, 538, 9, 538, 4, 539, 9, 539, 4, 540, 9, 540, 4, 541, 9, 541, 4, 542, 9, 542, 4, 543, 9, 543, 4, 544, 9, 544, 4, 545, 9, 545, 4, 546, 9, 546, 4, 547, 9, 547, 4, 548, 9, 548, 4, 549, 9, 549, 4, 550, 9, 550, 4, 551, 9, 551, 4, 552, 9, 552, 4, 553, 9, 553, 4, 554, 9, 554, 4, 555, 9, 555, 4, 556, 9, 556, 4, 557, 9, 557, 4, 558, 9, 558, 4, 559, 9, 559, 4, 560, 9, 560, 4, 561, 9, 561, 4, 562, 9, 562, 4, 563, 9, 563, 4, 564, 9, 564, 4, 565, 9, 565, 4, 566, 9, 566, 4, 567, 9, 567, 4, 568, 9, 568, 4, 569, 9, 569, 4, 570, 9, 570, 4, 571, 9, 571, 4, 572, 9, 572, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 9, 3, 9, 3, 10, 3, 10, 3, 11, 3, 11, 3, 12, 3, 12, 3, 13, 3, 13, 3, 14, 3, 14, 3, 15, 3, 15, 3, 16, 3, 16, 3, 17, 3, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 29, 3, 29, 6, 29, 1215, 10, 29, 13, 29, 14, 29, 1216, 3, 30, 3, 30, 3, 30, 3, 30, 6, 30, 1223, 10, 30, 13, 30, 14, 30, 1224, 3, 30, 3, 30, 3, 30, 5, 30, 1230, 10, 30, 3, 30, 3, 30, 6, 30, 1234, 10, 30, 13, 30, 14, 30, 1235, 3, 30, 5, 30, 1239, 10, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 7, 31, 1248, 10, 31, 12, 31, 14, 31, 1251, 11, 31, 3, 31, 3, 31, 5, 31, 1255, 10, 31, 3, 31, 3, 31, 3, 31, 6, 31, 1260, 10, 31, 13, 31, 14, 31, 1261, 3, 31, 3, 31, 3, 32, 3, 32, 3, 33, 3, 33, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 3, 92, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 93, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 94, 3, 95, 3, 95, 3, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 99, 3, 99, 3, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 121, 3, 121, 3, 121, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 138, 3, 138, 3, 138, 3, 138, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 3, 139, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 142, 3, 142, 3, 142, 3, 142, 3, 142, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 143, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 147, 3, 147, 3, 147, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 152, 3, 152, 3, 152, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 155, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 158, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 176, 3, 176, 3, 176, 3, 176, 3, 177, 3, 177, 3, 177, 3, 177, 3, 177, 3, 177, 3, 177, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 181, 3, 181, 3, 181, 3, 181, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 183, 3, 183, 3, 183, 3, 183, 3, 183, 3, 183, 3, 183, 3, 183, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 198, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 199, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 200, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 208, 3, 209, 3, 209, 3, 209, 3, 209, 3, 209, 3, 209, 3, 209, 3, 209, 3, 209, 3, 209, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 211, 3, 212, 3, 212, 3, 212, 3, 212, 3, 212, 3, 212, 3, 213, 3, 213, 3, 213, 3, 213, 3, 213, 3, 213, 3, 213, 3, 213, 3, 213, 3, 213, 3, 214, 3, 214, 3, 214, 3, 214, 3, 214, 3, 214, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 215, 3, 216, 3, 216, 3, 216, 3, 216, 3, 216, 3, 216, 3, 216, 3, 216, 3, 216, 3, 217, 3, 217, 3, 217, 3, 217, 3, 217, 3, 217, 3, 217, 3, 217, 3, 217, 3, 217, 3, 218, 3, 218, 3, 218, 3, 218, 3, 218, 3, 218, 3, 218, 3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 3, 219, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 221, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 225, 3, 225, 3, 225, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 232, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 235, 3, 235, 3, 235, 3, 235, 3, 235, 3, 235, 3, 235, 3, 236, 3, 236, 3, 236, 3, 236, 3, 236, 3, 236, 3, 236, 3, 236, 3, 236, 3, 236, 3, 236, 3, 236, 3, 237, 3, 237, 3, 237, 3, 237, 3, 237, 3, 237, 3, 237, 3, 238, 3, 238, 3, 238, 3, 238, 3, 238, 3, 238, 3, 238, 3, 238, 3, 239, 3, 239, 3, 239, 3, 239, 3, 239, 3, 239, 3, 239, 3, 239, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 241, 3, 241, 3, 241, 3, 241, 3, 242, 3, 242, 3, 242, 3, 242, 3, 242, 3, 242, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 246, 3, 246, 3, 246, 3, 246, 3, 246, 3, 246, 3, 246, 3, 246, 3, 246, 3, 246, 3, 247, 3, 247, 3, 247, 3, 247, 3, 247, 3, 247, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 249, 3, 249, 3, 249, 3, 249, 3, 249, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 263, 3, 263, 3, 263, 3, 263, 3, 263, 3, 263, 3, 264, 3, 264, 3, 264, 3, 264, 3, 264, 3, 265, 3, 265, 3, 265, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 266, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 271, 3, 271, 3, 271, 3, 272, 3, 272, 3, 272, 3, 272, 3, 273, 3, 273, 3, 273, 3, 273, 3, 273, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 276, 3, 276, 3, 276, 3, 276, 3, 276, 3, 276, 3, 276, 3, 276, 3, 277, 3, 277, 3, 277, 3, 277, 3, 277, 3, 277, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 284, 3, 284, 3, 284, 3, 284, 3, 284, 3, 284, 3, 285, 3, 285, 3, 285, 3, 285, 3, 285, 3, 285, 3, 285, 3, 285, 3, 285, 3, 285, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 289, 3, 289, 3, 289, 3, 289, 3, 289, 3, 289, 3, 290, 3, 290, 3, 290, 3, 290, 3, 290, 3, 290, 3, 290, 3, 290, 3, 290, 3, 290, 3, 290, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 297, 3, 297, 3, 297, 3, 297, 3, 297, 3, 297, 3, 297, 3, 297, 3, 297, 3, 298, 3, 298, 3, 298, 3, 298, 3, 298, 3, 298, 3, 298, 3, 298, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 300, 3, 300, 3, 300, 3, 300, 3, 301, 3, 301, 3, 301, 3, 301, 3, 301, 3, 301, 3, 301, 3, 301, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 304, 3, 304, 3, 304, 3, 304, 3, 304, 3, 304, 3, 304, 3, 304, 3, 305, 3, 305, 3, 305, 3, 305, 3, 305, 3, 305, 3, 305, 3, 306, 3, 306, 3, 306, 3, 306, 3, 306, 3, 306, 3, 306, 3, 306, 3, 306, 3, 306, 3, 306, 3, 307, 3, 307, 3, 307, 3, 307, 3, 307, 3, 307, 3, 307, 3, 307, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 311, 3, 311, 3, 311, 3, 311, 3, 311, 3, 311, 3, 311, 3, 311, 3, 311, 3, 312, 3, 312, 3, 312, 3, 312, 3, 312, 3, 312, 3, 312, 3, 312, 3, 313, 3, 313, 3, 313, 3, 313, 3, 313, 3, 313, 3, 313, 3, 314, 3, 314, 3, 314, 3, 314, 3, 314, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 316, 3, 316, 3, 316, 3, 316, 3, 316, 3, 317, 3, 317, 3, 317, 3, 317, 3, 317, 3, 318, 3, 318, 3, 318, 3, 318, 3, 318, 3, 318, 3, 318, 3, 318, 3, 318, 3, 318, 3, 319, 3, 319, 3, 319, 3, 319, 3, 319, 3, 319, 3, 319, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 3, 320, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 323, 3, 323, 3, 323, 3, 323, 3, 323, 3, 323, 3, 323, 3, 323, 3, 323, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 327, 3, 327, 3, 327, 3, 327, 3, 327, 3, 327, 3, 327, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 329, 3, 329, 3, 329, 3, 329, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 3, 332, 3, 332, 3, 332, 3, 332, 3, 332, 3, 332, 3, 332, 3, 333, 3, 333, 3, 333, 3, 333, 3, 333, 3, 333, 3, 333, 3, 333, 3, 333, 3, 334, 3, 334, 3, 334, 3, 334, 3, 334, 3, 334, 3, 334, 3, 335, 3, 335, 3, 335, 3, 335, 3, 335, 3, 335, 3, 335, 3, 335, 3, 335, 3, 335, 3, 335, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 338, 3, 338, 3, 338, 3, 338, 3, 338, 3, 338, 3, 338, 3, 338, 3, 338, 3, 338, 3, 338, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 344, 3, 344, 3, 344, 3, 344, 3, 344, 3, 344, 3, 345, 3, 345, 3, 345, 3, 345, 3, 345, 3, 345, 3, 345, 3, 346, 3, 346, 3, 346, 3, 346, 3, 346, 3, 346, 3, 346, 3, 347, 3, 347, 3, 347, 3, 347, 3, 347, 3, 347, 3, 347, 3, 347, 3, 347, 3, 347, 3, 347, 3, 348, 3, 348, 3, 348, 3, 348, 3, 348, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 351, 3, 351, 3, 351, 3, 351, 3, 351, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 353, 3, 353, 3, 353, 3, 353, 3, 353, 3, 353, 3, 353, 3, 353, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 358, 3, 358, 3, 358, 3, 358, 3, 358, 3, 358, 3, 358, 3, 358, 3, 358, 3, 358, 3, 359, 3, 359, 3, 359, 3, 359, 3, 359, 3, 359, 3, 359, 3, 359, 3, 359, 3, 359, 3, 359, 3, 359, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 360, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 364, 3, 364, 3, 364, 3, 364, 3, 364, 3, 364, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 370, 3, 370, 3, 370, 3, 370, 3, 370, 3, 370, 3, 370, 3, 370, 3, 371, 3, 371, 3, 371, 3, 371, 3, 371, 3, 371, 3, 371, 3, 371, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 376, 3, 376, 3, 376, 3, 376, 3, 376, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 379, 3, 379, 3, 379, 3, 379, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 381, 3, 381, 3, 381, 3, 381, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 385, 3, 385, 3, 385, 3, 385, 3, 386, 3, 386, 3, 386, 3, 386, 3, 386, 3, 386, 3, 386, 3, 386, 3, 387, 3, 387, 3, 387, 3, 387, 3, 387, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 389, 3, 389, 3, 389, 3, 389, 3, 389, 3, 389, 3, 389, 3, 389, 3, 389, 3, 390, 3, 390, 3, 390, 3, 390, 3, 391, 3, 391, 3, 391, 3, 391, 3, 391, 3, 391, 3, 391, 3, 391, 3, 392, 3, 392, 3, 392, 3, 392, 3, 392, 3, 392, 3, 392, 3, 393, 3, 393, 3, 393, 3, 393, 3, 393, 3, 393, 3, 393, 3, 393, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 396, 3, 396, 3, 396, 3, 396, 3, 396, 3, 396, 3, 397, 3, 397, 3, 397, 3, 397, 3, 398, 3, 398, 3, 398, 3, 398, 3, 398, 3, 398, 3, 398, 3, 398, 3, 399, 3, 399, 3, 399, 3, 399, 3, 399, 3, 399, 3, 399, 3, 399, 3, 399, 3, 400, 3, 400, 3, 400, 3, 400, 3, 400, 3, 400, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 402, 3, 402, 3, 402, 3, 402, 3, 402, 3, 402, 3, 403, 3, 403, 3, 403, 3, 403, 3, 403, 3, 404, 3, 404, 3, 404, 3, 404, 3, 404, 3, 404, 3, 404, 3, 405, 3, 405, 3, 405, 3, 405, 3, 405, 3, 405, 3, 405, 3, 405, 3, 406, 3, 406, 3, 406, 3, 406, 3, 406, 3, 406, 3, 406, 3, 406, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 408, 3, 408, 3, 408, 3, 408, 3, 408, 3, 408, 3, 408, 3, 408, 3, 408, 3, 408, 3, 409, 3, 409, 3, 409, 3, 409, 3, 409, 3, 410, 3, 410, 3, 410, 3, 410, 3, 411, 3, 411, 3, 411, 3, 411, 3, 411, 3, 411, 3, 412, 3, 412, 3, 412, 3, 412, 3, 412, 3, 412, 3, 412, 3, 412, 3, 412, 3, 413, 3, 413, 3, 413, 3, 413, 3, 413, 3, 413, 3, 413, 3, 413, 3, 413, 3, 413, 3, 414, 3, 414, 3, 414, 3, 414, 3, 414, 3, 415, 3, 415, 3, 415, 3, 415, 3, 415, 3, 415, 3, 415, 3, 415, 3, 415, 3, 415, 3, 416, 3, 416, 3, 416, 3, 416, 3, 416, 3, 416, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 419, 3, 419, 3, 419, 3, 419, 3, 419, 3, 419, 3, 419, 3, 419, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 425, 3, 425, 3, 425, 3, 425, 3, 425, 3, 425, 3, 425, 3, 425, 3, 425, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 428, 3, 428, 3, 428, 3, 428, 3, 428, 3, 428, 3, 428, 3, 428, 3, 428, 3, 428, 3, 428, 3, 428, 3, 428, 3, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 430, 3, 430, 3, 430, 3, 430, 3, 430, 3, 430, 3, 430, 3, 430, 3, 431, 3, 431, 3, 431, 3, 431, 3, 431, 3, 431, 3, 431, 3, 432, 3, 432, 3, 432, 3, 432, 3, 432, 3, 432, 3, 432, 3, 433, 3, 433, 3, 433, 3, 433, 3, 433, 3, 433, 3, 433, 3, 433, 3, 433, 3, 433, 3, 433, 3, 434, 3, 434, 3, 434, 3, 434, 3, 434, 3, 434, 3, 434, 3, 434, 3, 434, 3, 434, 3, 435, 3, 435, 3, 435, 3, 435, 3, 435, 3, 435, 3, 435, 3, 436, 3, 436, 3, 436, 3, 436, 3, 436, 3, 436, 3, 436, 3, 437, 3, 437, 3, 437, 3, 437, 3, 437, 3, 437, 3, 437, 3, 437, 3, 438, 3, 438, 3, 438, 3, 438, 3, 438, 3, 438, 3, 438, 3, 438, 3, 439, 3, 439, 3, 439, 3, 439, 3, 439, 3, 439, 3, 439, 3, 439, 3, 439, 3, 439, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 442, 3, 442, 3, 442, 3, 442, 3, 442, 3, 442, 3, 442, 3, 443, 3, 443, 3, 443, 3, 443, 3, 443, 3, 443, 3, 443, 3, 443, 3, 443, 3, 443, 3, 443, 3, 443, 3, 444, 3, 444, 3, 444, 3, 444, 3, 445, 3, 445, 3, 445, 3, 445, 3, 446, 3, 446, 3, 446, 3, 446, 3, 446, 3, 446, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 449, 3, 449, 3, 449, 3, 449, 3, 450, 3, 450, 3, 450, 3, 450, 3, 451, 3, 451, 3, 451, 3, 451, 3, 451, 3, 451, 3, 451, 3, 451, 3, 451, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 457, 3, 457, 3, 457, 3, 457, 3, 458, 3, 458, 3, 458, 3, 458, 3, 458, 3, 458, 3, 458, 3, 458, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 460, 3, 460, 3, 460, 3, 460, 3, 460, 3, 460, 3, 460, 3, 460, 3, 460, 3, 461, 3, 461, 3, 461, 3, 461, 3, 461, 3, 462, 3, 462, 3, 462, 3, 462, 3, 462, 3, 462, 3, 462, 3, 463, 3, 463, 3, 463, 3, 463, 3, 463, 3, 464, 3, 464, 3, 464, 3, 464, 3, 464, 3, 464, 3, 464, 3, 465, 3, 465, 3, 465, 3, 465, 3, 465, 3, 466, 3, 466, 3, 466, 3, 466, 3, 466, 3, 466, 3, 466, 3, 466, 3, 466, 3, 467, 3, 467, 3, 467, 3, 467, 3, 467, 3, 468, 3, 468, 3, 468, 3, 468, 3, 468, 3, 468, 3, 468, 3, 468, 3, 468, 3, 468, 3, 468, 3, 468, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 472, 3, 472, 3, 472, 3, 472, 3, 472, 3, 472, 3, 472, 3, 472, 3, 472, 3, 472, 3, 472, 3, 472, 3, 472, 3, 472, 3, 473, 3, 473, 3, 473, 3, 473, 3, 473, 3, 473, 3, 473, 3, 473, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 475, 3, 475, 3, 475, 3, 475, 3, 475, 3, 475, 3, 475, 3, 476, 3, 476, 3, 476, 3, 476, 3, 476, 3, 476, 3, 476, 3, 477, 3, 477, 3, 477, 3, 477, 3, 477, 3, 477, 3, 477, 3, 478, 3, 478, 3, 478, 3, 478, 3, 478, 3, 478, 3, 478, 3, 479, 3, 479, 3, 479, 3, 479, 3, 480, 3, 480, 3, 480, 3, 480, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 483, 3, 483, 3, 483, 3, 483, 3, 483, 3, 483, 3, 483, 3, 483, 3, 484, 3, 484, 3, 484, 3, 484, 3, 484, 3, 484, 3, 485, 3, 485, 3, 485, 3, 485, 3, 485, 3, 485, 3, 485, 3, 485, 3, 485, 3, 485, 3, 486, 3, 486, 3, 486, 3, 486, 3, 486, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 489, 3, 489, 3, 489, 3, 489, 3, 489, 3, 489, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 3, 491, 3, 491, 3, 491, 3, 491, 3, 491, 3, 491, 3, 491, 3, 491, 3, 491, 3, 491, 3, 491, 3, 492, 3, 492, 3, 492, 3, 492, 3, 492, 3, 492, 3, 493, 3, 493, 3, 493, 3, 493, 3, 493, 3, 493, 3, 493, 3, 493, 3, 493, 3, 494, 3, 494, 3, 494, 3, 494, 3, 494, 3, 494, 3, 494, 3, 494, 3, 495, 3, 495, 3, 495, 3, 495, 3, 496, 3, 496, 3, 496, 3, 496, 3, 496, 3, 496, 3, 496, 3, 496, 3, 496, 3, 496, 3, 496, 3, 496, 3, 497, 3, 497, 3, 497, 3, 497, 3, 497, 3, 497, 3, 497, 3, 497, 3, 498, 3, 498, 3, 498, 3, 498, 3, 498, 3, 498, 3, 499, 3, 499, 3, 499, 3, 499, 3, 499, 3, 499, 3, 500, 3, 500, 3, 500, 3, 500, 3, 500, 3, 500, 3, 500, 3, 500, 3, 501, 3, 501, 3, 501, 3, 501, 3, 501, 3, 501, 3, 501, 3, 501, 3, 502, 3, 502, 3, 502, 3, 502, 3, 502, 3, 502, 3, 503, 3, 503, 3, 503, 3, 503, 3, 503, 3, 504, 3, 504, 3, 504, 3, 504, 3, 504, 3, 504, 3, 504, 3, 505, 3, 505, 3, 505, 3, 505, 3, 505, 3, 505, 3, 506, 3, 506, 3, 506, 3, 506, 3, 506, 3, 506, 3, 507, 3, 507, 3, 507, 3, 507, 3, 507, 3, 507, 3, 507, 3, 507, 3, 507, 3, 508, 3, 508, 3, 508, 3, 508, 3, 508, 3, 508, 3, 509, 3, 509, 3, 509, 3, 509, 3, 510, 3, 510, 3, 510, 3, 510, 3, 510, 3, 511, 3, 511, 3, 511, 3, 511, 3, 511, 3, 511, 3, 511, 3, 512, 3, 512, 3, 512, 3, 512, 3, 512, 3, 512, 3, 512, 3, 512, 3, 513, 3, 513, 3, 513, 3, 513, 3, 513, 3, 513, 3, 513, 3, 513, 3, 513, 3, 513, 3, 514, 3, 514, 3, 514, 3, 514, 3, 514, 3, 514, 3, 514, 3, 515, 3, 515, 3, 515, 3, 515, 3, 515, 3, 516, 3, 516, 3, 516, 3, 516, 3, 516, 3, 517, 3, 517, 7, 517, 4938, 10, 517, 12, 517, 14, 517, 4941, 11, 517, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 5, 518, 4949, 10, 518, 3, 519, 3, 519, 5, 519, 4953, 10, 519, 3, 520, 3, 520, 5, 520, 4957, 10, 520, 3, 521, 3, 521, 3, 521, 3, 522, 3, 522, 3, 522, 3, 522, 7, 522, 4966, 10, 522, 12, 522, 14, 522, 4969, 11, 522, 3, 523, 3, 523, 3, 523, 3, 524, 3, 524, 3, 524, 3, 524, 7, 524, 4978, 10, 524, 12, 524, 14, 524, 4981, 11, 524, 3, 525, 3, 525, 3, 525, 3, 525, 3, 526, 3, 526, 3, 526, 3, 526, 3, 527, 3, 527, 3, 527, 3, 527, 3, 528, 3, 528, 3, 528, 3, 528, 3, 529, 3, 529, 3, 529, 3, 530, 3, 530, 3, 530, 3, 530, 7, 530, 5006, 10, 530, 12, 530, 14, 530, 5009, 11, 530, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 532, 3, 532, 3, 532, 3, 533, 3, 533, 3, 533, 3, 533, 3, 534, 3, 534, 5, 534, 5026, 10, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 535, 3, 535, 7, 535, 5035, 10, 535, 12, 535, 14, 535, 5038, 11, 535, 3, 536, 3, 536, 3, 536, 3, 537, 3, 537, 3, 537, 7, 537, 5046, 10, 537, 12, 537, 14, 537, 5049, 11, 537, 3, 538, 3, 538, 3, 538, 3, 539, 3, 539, 3, 539, 3, 540, 3, 540, 3, 540, 3, 541, 3, 541, 3, 541, 7, 541, 5063, 10, 541, 12, 541, 14, 541, 5066, 11, 541, 3, 542, 3, 542, 3, 542, 3, 543, 3, 543, 3, 543, 3, 544, 3, 544, 3, 545, 3, 545, 3, 545, 3, 545, 3, 545, 3, 545, 3, 546, 3, 546, 3, 546, 5, 546, 5085, 10, 546, 3, 546, 3, 546, 5, 546, 5089, 10, 546, 3, 546, 5, 546, 5092, 10, 546, 3, 546, 3, 546, 3, 546, 3, 546, 5, 546, 5098, 10, 546, 3, 546, 5, 546, 5101, 10, 546, 3, 546, 3, 546, 3, 546, 5, 546, 5106, 10, 546, 3, 546, 3, 546, 5, 546, 5110, 10, 546, 3, 547, 6, 547, 5113, 10, 547, 13, 547, 14, 547, 5114, 3, 548, 3, 548, 3, 548, 7, 548, 5120, 10, 548, 12, 548, 14, 548, 5123, 11, 548, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 7, 549, 5133, 10, 549, 12, 549, 14, 549, 5136, 11, 549, 3, 549, 3, 549, 3, 550, 6, 550, 5141, 10, 550, 13, 550, 14, 550, 5142, 3, 550, 3, 550, 3, 551, 3, 551, 5, 551, 5149, 10, 551, 3, 551, 5, 551, 5152, 10, 551, 3, 551, 3, 551, 3, 552, 3, 552, 3, 552, 3, 552, 7, 552, 5160, 10, 552, 12, 552, 14, 552, 5163, 11, 552, 3, 552, 3, 552, 3, 553, 3, 553, 3, 553, 3, 553, 7, 553, 5171, 10, 553, 12, 553, 14, 553, 5174, 11, 553, 3, 553, 3, 553, 3, 553, 6, 553, 5179, 10, 553, 13, 553, 14, 553, 5180, 3, 553, 3, 553, 6, 553, 5185, 10, 553, 13, 553, 14, 553, 5186, 3, 553, 7, 553, 5190, 10, 553, 12, 553, 14, 553, 5193, 11, 553, 3, 553, 7, 553, 5196, 10, 553, 12, 553, 14, 553, 5199, 11, 553, 3, 553, 3, 553, 3, 553, 3, 553, 3, 553, 3, 554, 3, 554, 3, 554, 3, 554, 7, 554, 5210, 10, 554, 12, 554, 14, 554, 5213, 11, 554, 3, 554, 3, 554, 3, 554, 6, 554, 5218, 10, 554, 13, 554, 14, 554, 5219, 3, 554, 3, 554, 6, 554, 5224, 10, 554, 13, 554, 14, 554, 5225, 3, 554, 5, 554, 5229, 10, 554, 7, 554, 5231, 10, 554, 12, 554, 14, 554, 5234, 11, 554, 3, 554, 6, 554, 5237, 10, 554, 13, 554, 14, 554, 5238, 3, 554, 6, 554, 5242, 10, 554, 13, 554, 14, 554, 5243, 3, 554, 7, 554, 5247, 10, 554, 12, 554, 14, 554, 5250, 11, 554, 3, 554, 5, 554, 5253, 10, 554, 3, 554, 3, 554, 3, 555, 3, 555, 3, 555, 3, 555, 7, 555, 5261, 10, 555, 12, 555, 14, 555, 5264, 11, 555, 3, 555, 7, 555, 5267, 10, 555, 12, 555, 14, 555, 5270, 11, 555, 3, 555, 3, 555, 7, 555, 5274, 10, 555, 12, 555, 14, 555, 5277, 11, 555, 5, 555, 5279, 10, 555, 3, 556, 3, 556, 3, 556, 3, 557, 3, 557, 3, 558, 3, 558, 3, 558, 3, 558, 3, 558, 3, 559, 3, 559, 5, 559, 5293, 10, 559, 3, 559, 3, 559, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 3, 560, 5, 560, 5317, 10, 560, 3, 560, 7, 560, 5320, 10, 560, 12, 560, 14, 560, 5323, 11, 560, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 3, 562, 3, 562, 5, 562, 5332, 10, 562, 3, 562, 3, 562, 3, 563, 3, 563, 3, 563, 3, 563, 3, 563, 7, 563, 5341, 10, 563, 12, 563, 14, 563, 5344, 11, 563, 3, 564, 3, 564, 3, 564, 3, 564, 3, 564, 3, 565, 3, 565, 3, 565, 3, 565, 3, 565, 3, 565, 3, 566, 3, 566, 3, 566, 3, 566, 3, 566, 3, 567, 3, 567, 3, 567, 3, 567, 3, 567, 3, 568, 3, 568, 3, 568, 3, 568, 3, 568, 3, 569, 3, 569, 3, 569, 3, 569, 3, 569, 3, 570, 3, 570, 3, 570, 3, 570, 3, 570, 3, 571, 6, 571, 5383, 10, 571, 13, 571, 14, 571, 5384, 3, 571, 3, 571, 7, 571, 5389, 10, 571, 12, 571, 14, 571, 5392, 11, 571, 5, 571, 5394, 10, 571, 3, 572, 3, 572, 5, 572, 5398, 10, 572, 3, 572, 3, 572, 3, 572, 3, 572, 3, 572, 3, 572, 3, 572, 2, 2, 573, 7, 3, 9, 4, 11, 5, 13, 6, 15, 7, 17, 8, 19, 9, 21, 10, 23, 11, 25, 12, 27, 13, 29, 14, 31, 15, 33, 16, 35, 17, 37, 18, 39, 19, 41, 20, 43, 21, 45, 22, 47, 23, 49, 24, 51, 25, 53, 26, 55, 27, 57, 28, 59, 29, 61, 30, 63, 31, 65, 2, 67, 2, 69, 2, 71, 2, 73, 32, 75, 33, 77, 34, 79, 35, 81, 36, 83, 37, 85, 38, 87, 39, 89, 40, 91, 41, 93, 42, 95, 43, 97, 44, 99, 45, 101, 46, 103, 47, 105, 48, 107, 49, 109, 50, 111, 51, 113, 52, 115, 53, 117, 54, 119, 55, 121, 56, 123, 57, 125, 58, 127, 59, 129, 60, 131, 61, 133, 62, 135, 63, 137, 64, 139, 65, 141, 66, 143, 67, 145, 68, 147, 69, 149, 70, 151, 71, 153, 72, 155, 73, 157, 74, 159, 75, 161, 76, 163, 77, 165, 78, 167, 79, 169, 80, 171, 81, 173, 82, 175, 83, 177, 84, 179, 85, 181, 86, 183, 87, 185, 88, 187, 89, 189, 90, 191, 91, 193, 92, 195, 93, 197, 94, 199, 95, 201, 96, 203, 97, 205, 98, 207, 99, 209, 100, 211, 101, 213, 102, 215, 103, 217, 104, 219, 105, 221, 106, 223, 107, 225, 108, 227, 109, 229, 110, 231, 111, 233, 112, 235, 113, 237, 114, 239, 115, 241, 116, 243, 117, 245, 118, 247, 119, 249, 120, 251, 121, 253, 122, 255, 123, 257, 124, 259, 125, 261, 126, 263, 127, 265, 128, 267, 129, 269, 130, 271, 131, 273, 132, 275, 133, 277, 134, 279, 135, 281, 136, 283, 137, 285, 138, 287, 139, 289, 140, 291, 141, 293, 142, 295, 143, 297, 144, 299, 145, 301, 146, 303, 147, 305, 148, 307, 149, 309, 150, 311, 151, 313, 152, 315, 153, 317, 154, 319, 155, 321, 156, 323, 157, 325, 158, 327, 159, 329, 160, 331, 161, 333, 162, 335, 163, 337, 164, 339, 165, 341, 166, 343, 167, 345, 168, 347, 169, 349, 170, 351, 171, 353, 172, 355, 173, 357, 174, 359, 175, 361, 176, 363, 177, 365, 178, 367, 179, 369, 180, 371, 181, 373, 182, 375, 183, 377, 184, 379, 185, 381, 186, 383, 187, 385, 188, 387, 189, 389, 190, 391, 191, 393, 192, 395, 193, 397, 194, 399, 195, 401, 196, 403, 197, 405, 198, 407, 199, 409, 200, 411, 201, 413, 202, 415, 203, 417, 204, 419, 205, 421, 206, 423, 207, 425, 208, 427, 209, 429, 210, 431, 211, 433, 212, 435, 213, 437, 214, 439, 215, 441, 216, 443, 217, 445, 218, 447, 219, 449, 220, 451, 221, 453, 222, 455, 223, 457, 224, 459, 225, 461, 226, 463, 227, 465, 228, 467, 229, 469, 230, 471, 231, 473, 232, 475, 233, 477, 234, 479, 235, 481, 236, 483, 237, 485, 238, 487, 239, 489, 240, 491, 241, 493, 242, 495, 243, 497, 244, 499, 245, 501, 246, 503, 247, 505, 248, 507, 249, 509, 250, 511, 251, 513, 252, 515, 253, 517, 254, 519, 255, 521, 256, 523, 257, 525, 258, 527, 259, 529, 260, 531, 261, 533, 262, 535, 263, 537, 264, 539, 265, 541, 266, 543, 267, 545, 268, 547, 269, 549, 270, 551, 271, 553, 272, 555, 273, 557, 274, 559, 275, 561, 276, 563, 277, 565, 278, 567, 279, 569, 280, 571, 281, 573, 282, 575, 283, 577, 284, 579, 285, 581, 286, 583, 287, 585, 288, 587, 289, 589, 290, 591, 291, 593, 292, 595, 293, 597, 294, 599, 295, 601, 296, 603, 297, 605, 298, 607, 299, 609, 300, 611, 301, 613, 302, 615, 303, 617, 304, 619, 305, 621, 306, 623, 307, 625, 308, 627, 309, 629, 310, 631, 311, 633, 312, 635, 313, 637, 314, 639, 315, 641, 316, 643, 317, 645, 318, 647, 319, 649, 320, 651, 321, 653, 322, 655, 323, 657, 324, 659, 325, 661, 326, 663, 327, 665, 328, 667, 329, 669, 330, 671, 331, 673, 332, 675, 333, 677, 334, 679, 335, 681, 336, 683, 337, 685, 338, 687, 339, 689, 340, 691, 341, 693, 342, 695, 343, 697, 344, 699, 345, 701, 346, 703, 347, 705, 348, 707, 349, 709, 350, 711, 351, 713, 352, 715, 353, 717, 354, 719, 355, 721, 356, 723, 357, 725, 358, 727, 359, 729, 360, 731, 361, 733, 362, 735, 363, 737, 364, 739, 365, 741, 366, 743, 367, 745, 368, 747, 369, 749, 370, 751, 371, 753, 372, 755, 373, 757, 374, 759, 375, 761, 376, 763, 377, 765, 378, 767, 379, 769, 380, 771, 381, 773, 382, 775, 383, 777, 384, 779, 385, 781, 386, 783, 387, 785, 388, 787, 389, 789, 390, 791, 391, 793, 392, 795, 393, 797, 394, 799, 395, 801, 396, 803, 397, 805, 398, 807, 399, 809, 400, 811, 401, 813, 402, 815, 403, 817, 404, 819, 405, 821, 406, 823, 407, 825, 408, 827, 409, 829, 410, 831, 411, 833, 412, 835, 413, 837, 414, 839, 415, 841, 416, 843, 417, 845, 418, 847, 419, 849, 420, 851, 421, 853, 422, 855, 423, 857, 424, 859, 425, 861, 426, 863, 427, 865, 428, 867, 429, 869, 430, 871, 431, 873, 432, 875, 433, 877, 434, 879, 435, 881, 436, 883, 437, 885, 438, 887, 439, 889, 440, 891, 441, 893, 442, 895, 443, 897, 444, 899, 445, 901, 446, 903, 447, 905, 448, 907, 449, 909, 450, 911, 451, 913, 452, 915, 453, 917, 454, 919, 455, 921, 456, 923, 457, 925, 458, 927, 459, 929, 460, 931, 461, 933, 462, 935, 463, 937, 464, 939, 465, 941, 466, 943, 467, 945, 468, 947, 469, 949, 470, 951, 471, 953, 472, 955, 473, 957, 474, 959, 475, 961, 476, 963, 477, 965, 478, 967, 479, 969, 480, 971, 481, 973, 482, 975, 483, 977, 484, 979, 485, 981, 486, 983, 487, 985, 488, 987, 489, 989, 490, 991, 491, 993, 492, 995, 493, 997, 494, 999, 495, 1001, 496, 1003, 497, 1005, 498, 1007, 499, 1009, 500, 1011, 501, 1013, 502, 1015, 503, 1017, 504, 1019, 505, 1021, 506, 1023, 507, 1025, 508, 1027, 509, 1029, 510, 1031, 511, 1033, 512, 1035, 513, 1037, 514, 1039, 2, 1041, 2, 1043, 2, 1045, 515, 1047, 516, 1049, 517, 1051, 518, 1053, 519, 1055, 520, 1057, 521, 1059, 522, 1061, 523, 1063, 524, 1065, 2, 1067, 525, 1069, 526, 1071, 527, 1073, 2, 1075, 528, 1077, 529, 1079, 530, 1081, 531, 1083, 532, 1085, 533, 1087, 534, 1089, 535, 1091, 536, 1093, 537, 1095, 538, 1097, 2, 1099, 539, 1101, 540, 1103, 541, 1105, 542, 1107, 543, 1109, 544, 1111, 545, 1113, 546, 1115, 547, 1117, 548, 1119, 549, 1121, 550, 1123, 2, 1125, 551, 1127, 552, 1129, 2, 1131, 2, 1133, 2, 1135, 553, 1137, 2, 1139, 2, 1141, 557, 1143, 554, 1145, 555, 1147, 556, 7, 2, 3, 4, 5, 6, 28, 3, 2, 50, 59, 4, 2, 45, 45, 47, 47, 11, 2, 35, 35, 37, 37, 39, 40, 44, 44, 62, 66, 96, 96, 98, 98, 126, 126, 128, 128, 4, 2, 44, 45, 62, 64, 10, 2, 35, 35, 37, 37, 39, 40, 65, 66, 96, 96, 98, 98, 126, 126, 128, 128, 11, 2, 67, 92, 97, 97, 99, 124, 172, 172, 183, 183, 188, 188, 194, 216, 218, 248, 250, 257, 4, 2, 258, 55297, 57346, 1, 3, 2, 55298, 56321, 3, 2, 56322, 57345, 4, 2, 2, 2, 36, 36, 3, 2, 36, 36, 3, 2, 41, 41, 3, 2, 50, 51, 4, 2, 50, 59, 67, 72, 4, 2, 67, 92, 97, 97, 6, 2, 38, 38, 50, 59, 67, 92, 97, 97, 4, 2, 36, 36, 94, 94, 4, 2, 11, 11, 34, 34, 4, 2, 12, 12, 15, 15, 4, 2, 44, 44, 49, 49, 6, 2, 12, 12, 15, 15, 36, 36, 94, 94, 5, 2, 12, 12, 15, 15, 36, 36, 5, 2, 50, 59, 67, 72, 99, 104, 5, 2, 87, 87, 119, 119, 122, 122, 4, 2, 41, 41, 94, 94, 3, 2, 38, 38, 2, 5478, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2, 83, 3, 2, 2, 2, 2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2, 2, 91, 3, 2, 2, 2, 2, 93, 3, 2, 2, 2, 2, 95, 3, 2, 2, 2, 2, 97, 3, 2, 2, 2, 2, 99, 3, 2, 2, 2, 2, 101, 3, 2, 2, 2, 2, 103, 3, 2, 2, 2, 2, 105, 3, 2, 2, 2, 2, 107, 3, 2, 2, 2, 2, 109, 3, 2, 2, 2, 2, 111, 3, 2, 2, 2, 2, 113, 3, 2, 2, 2, 2, 115, 3, 2, 2, 2, 2, 117, 3, 2, 2, 2, 2, 119, 3, 2, 2, 2, 2, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 2, 125, 3, 2, 2, 2, 2, 127, 3, 2, 2, 2, 2, 129, 3, 2, 2, 2, 2, 131, 3, 2, 2, 2, 2, 133, 3, 2, 2, 2, 2, 135, 3, 2, 2, 2, 2, 137, 3, 2, 2, 2, 2, 139, 3, 2, 2, 2, 2, 141, 3, 2, 2, 2, 2, 143, 3, 2, 2, 2, 2, 145, 3, 2, 2, 2, 2, 147, 3, 2, 2, 2, 2, 149, 3, 2, 2, 2, 2, 151, 3, 2, 2, 2, 2, 153, 3, 2, 2, 2, 2, 155, 3, 2, 2, 2, 2, 157, 3, 2, 2, 2, 2, 159, 3, 2, 2, 2, 2, 161, 3, 2, 2, 2, 2, 163, 3, 2, 2, 2, 2, 165, 3, 2, 2, 2, 2, 167, 3, 2, 2, 2, 2, 169, 3, 2, 2, 2, 2, 171, 3, 2, 2, 2, 2, 173, 3, 2, 2, 2, 2, 175, 3, 2, 2, 2, 2, 177, 3, 2, 2, 2, 2, 179, 3, 2, 2, 2, 2, 181, 3, 2, 2, 2, 2, 183, 3, 2, 2, 2, 2, 185, 3, 2, 2, 2, 2, 187, 3, 2, 2, 2, 2, 189, 3, 2, 2, 2, 2, 191, 3, 2, 2, 2, 2, 193, 3, 2, 2, 2, 2, 195, 3, 2, 2, 2, 2, 197, 3, 2, 2, 2, 2, 199, 3, 2, 2, 2, 2, 201, 3, 2, 2, 2, 2, 203, 3, 2, 2, 2, 2, 205, 3, 2, 2, 2, 2, 207, 3, 2, 2, 2, 2, 209, 3, 2, 2, 2, 2, 211, 3, 2, 2, 2, 2, 213, 3, 2, 2, 2, 2, 215, 3, 2, 2, 2, 2, 217, 3, 2, 2, 2, 2, 219, 3, 2, 2, 2, 2, 221, 3, 2, 2, 2, 2, 223, 3, 2, 2, 2, 2, 225, 3, 2, 2, 2, 2, 227, 3, 2, 2, 2, 2, 229, 3, 2, 2, 2, 2, 231, 3, 2, 2, 2, 2, 233, 3, 2, 2, 2, 2, 235, 3, 2, 2, 2, 2, 237, 3, 2, 2, 2, 2, 239, 3, 2, 2, 2, 2, 241, 3, 2, 2, 2, 2, 243, 3, 2, 2, 2, 2, 245, 3, 2, 2, 2, 2, 247, 3, 2, 2, 2, 2, 249, 3, 2, 2, 2, 2, 251, 3, 2, 2, 2, 2, 253, 3, 2, 2, 2, 2, 255, 3, 2, 2, 2, 2, 257, 3, 2, 2, 2, 2, 259, 3, 2, 2, 2, 2, 261, 3, 2, 2, 2, 2, 263, 3, 2, 2, 2, 2, 265, 3, 2, 2, 2, 2, 267, 3, 2, 2, 2, 2, 269, 3, 2, 2, 2, 2, 271, 3, 2, 2, 2, 2, 273, 3, 2, 2, 2, 2, 275, 3, 2, 2, 2, 2, 277, 3, 2, 2, 2, 2, 279, 3, 2, 2, 2, 2, 281, 3, 2, 2, 2, 2, 283, 3, 2, 2, 2, 2, 285, 3, 2, 2, 2, 2, 287, 3, 2, 2, 2, 2, 289, 3, 2, 2, 2, 2, 291, 3, 2, 2, 2, 2, 293, 3, 2, 2, 2, 2, 295, 3, 2, 2, 2, 2, 297, 3, 2, 2, 2, 2, 299, 3, 2, 2, 2, 2, 301, 3, 2, 2, 2, 2, 303, 3, 2, 2, 2, 2, 305, 3, 2, 2, 2, 2, 307, 3, 2, 2, 2, 2, 309, 3, 2, 2, 2, 2, 311, 3, 2, 2, 2, 2, 313, 3, 2, 2, 2, 2, 315, 3, 2, 2, 2, 2, 317, 3, 2, 2, 2, 2, 319, 3, 2, 2, 2, 2, 321, 3, 2, 2, 2, 2, 323, 3, 2, 2, 2, 2, 325, 3, 2, 2, 2, 2, 327, 3, 2, 2, 2, 2, 329, 3, 2, 2, 2, 2, 331, 3, 2, 2, 2, 2, 333, 3, 2, 2, 2, 2, 335, 3, 2, 2, 2, 2, 337, 3, 2, 2, 2, 2, 339, 3, 2, 2, 2, 2, 341, 3, 2, 2, 2, 2, 343, 3, 2, 2, 2, 2, 345, 3, 2, 2, 2, 2, 347, 3, 2, 2, 2, 2, 349, 3, 2, 2, 2, 2, 351, 3, 2, 2, 2, 2, 353, 3, 2, 2, 2, 2, 355, 3, 2, 2, 2, 2, 357, 3, 2, 2, 2, 2, 359, 3, 2, 2, 2, 2, 361, 3, 2, 2, 2, 2, 363, 3, 2, 2, 2, 2, 365, 3, 2, 2, 2, 2, 367, 3, 2, 2, 2, 2, 369, 3, 2, 2, 2, 2, 371, 3, 2, 2, 2, 2, 373, 3, 2, 2, 2, 2, 375, 3, 2, 2, 2, 2, 377, 3, 2, 2, 2, 2, 379, 3, 2, 2, 2, 2, 381, 3, 2, 2, 2, 2, 383, 3, 2, 2, 2, 2, 385, 3, 2, 2, 2, 2, 387, 3, 2, 2, 2, 2, 389, 3, 2, 2, 2, 2, 391, 3, 2, 2, 2, 2, 393, 3, 2, 2, 2, 2, 395, 3, 2, 2, 2, 2, 397, 3, 2, 2, 2, 2, 399, 3, 2, 2, 2, 2, 401, 3, 2, 2, 2, 2, 403, 3, 2, 2, 2, 2, 405, 3, 2, 2, 2, 2, 407, 3, 2, 2, 2, 2, 409, 3, 2, 2, 2, 2, 411, 3, 2, 2, 2, 2, 413, 3, 2, 2, 2, 2, 415, 3, 2, 2, 2, 2, 417, 3, 2, 2, 2, 2, 419, 3, 2, 2, 2, 2, 421, 3, 2, 2, 2, 2, 423, 3, 2, 2, 2, 2, 425, 3, 2, 2, 2, 2, 427, 3, 2, 2, 2, 2, 429, 3, 2, 2, 2, 2, 431, 3, 2, 2, 2, 2, 433, 3, 2, 2, 2, 2, 435, 3, 2, 2, 2, 2, 437, 3, 2, 2, 2, 2, 439, 3, 2, 2, 2, 2, 441, 3, 2, 2, 2, 2, 443, 3, 2, 2, 2, 2, 445, 3, 2, 2, 2, 2, 447, 3, 2, 2, 2, 2, 449, 3, 2, 2, 2, 2, 451, 3, 2, 2, 2, 2, 453, 3, 2, 2, 2, 2, 455, 3, 2, 2, 2, 2, 457, 3, 2, 2, 2, 2, 459, 3, 2, 2, 2, 2, 461, 3, 2, 2, 2, 2, 463, 3, 2, 2, 2, 2, 465, 3, 2, 2, 2, 2, 467, 3, 2, 2, 2, 2, 469, 3, 2, 2, 2, 2, 471, 3, 2, 2, 2, 2, 473, 3, 2, 2, 2, 2, 475, 3, 2, 2, 2, 2, 477, 3, 2, 2, 2, 2, 479, 3, 2, 2, 2, 2, 481, 3, 2, 2, 2, 2, 483, 3, 2, 2, 2, 2, 485, 3, 2, 2, 2, 2, 487, 3, 2, 2, 2, 2, 489, 3, 2, 2, 2, 2, 491, 3, 2, 2, 2, 2, 493, 3, 2, 2, 2, 2, 495, 3, 2, 2, 2, 2, 497, 3, 2, 2, 2, 2, 499, 3, 2, 2, 2, 2, 501, 3, 2, 2, 2, 2, 503, 3, 2, 2, 2, 2, 505, 3, 2, 2, 2, 2, 507, 3, 2, 2, 2, 2, 509, 3, 2, 2, 2, 2, 511, 3, 2, 2, 2, 2, 513, 3, 2, 2, 2, 2, 515, 3, 2, 2, 2, 2, 517, 3, 2, 2, 2, 2, 519, 3, 2, 2, 2, 2, 521, 3, 2, 2, 2, 2, 523, 3, 2, 2, 2, 2, 525, 3, 2, 2, 2, 2, 527, 3, 2, 2, 2, 2, 529, 3, 2, 2, 2, 2, 531, 3, 2, 2, 2, 2, 533, 3, 2, 2, 2, 2, 535, 3, 2, 2, 2, 2, 537, 3, 2, 2, 2, 2, 539, 3, 2, 2, 2, 2, 541, 3, 2, 2, 2, 2, 543, 3, 2, 2, 2, 2, 545, 3, 2, 2, 2, 2, 547, 3, 2, 2, 2, 2, 549, 3, 2, 2, 2, 2, 551, 3, 2, 2, 2, 2, 553, 3, 2, 2, 2, 2, 555, 3, 2, 2, 2, 2, 557, 3, 2, 2, 2, 2, 559, 3, 2, 2, 2, 2, 561, 3, 2, 2, 2, 2, 563, 3, 2, 2, 2, 2, 565, 3, 2, 2, 2, 2, 567, 3, 2, 2, 2, 2, 569, 3, 2, 2, 2, 2, 571, 3, 2, 2, 2, 2, 573, 3, 2, 2, 2, 2, 575, 3, 2, 2, 2, 2, 577, 3, 2, 2, 2, 2, 579, 3, 2, 2, 2, 2, 581, 3, 2, 2, 2, 2, 583, 3, 2, 2, 2, 2, 585, 3, 2, 2, 2, 2, 587, 3, 2, 2, 2, 2, 589, 3, 2, 2, 2, 2, 591, 3, 2, 2, 2, 2, 593, 3, 2, 2, 2, 2, 595, 3, 2, 2, 2, 2, 597, 3, 2, 2, 2, 2, 599, 3, 2, 2, 2, 2, 601, 3, 2, 2, 2, 2, 603, 3, 2, 2, 2, 2, 605, 3, 2, 2, 2, 2, 607, 3, 2, 2, 2, 2, 609, 3, 2, 2, 2, 2, 611, 3, 2, 2, 2, 2, 613, 3, 2, 2, 2, 2, 615, 3, 2, 2, 2, 2, 617, 3, 2, 2, 2, 2, 619, 3, 2, 2, 2, 2, 621, 3, 2, 2, 2, 2, 623, 3, 2, 2, 2, 2, 625, 3, 2, 2, 2, 2, 627, 3, 2, 2, 2, 2, 629, 3, 2, 2, 2, 2, 631, 3, 2, 2, 2, 2, 633, 3, 2, 2, 2, 2, 635, 3, 2, 2, 2, 2, 637, 3, 2, 2, 2, 2, 639, 3, 2, 2, 2, 2, 641, 3, 2, 2, 2, 2, 643, 3, 2, 2, 2, 2, 645, 3, 2, 2, 2, 2, 647, 3, 2, 2, 2, 2, 649, 3, 2, 2, 2, 2, 651, 3, 2, 2, 2, 2, 653, 3, 2, 2, 2, 2, 655, 3, 2, 2, 2, 2, 657, 3, 2, 2, 2, 2, 659, 3, 2, 2, 2, 2, 661, 3, 2, 2, 2, 2, 663, 3, 2, 2, 2, 2, 665, 3, 2, 2, 2, 2, 667, 3, 2, 2, 2, 2, 669, 3, 2, 2, 2, 2, 671, 3, 2, 2, 2, 2, 673, 3, 2, 2, 2, 2, 675, 3, 2, 2, 2, 2, 677, 3, 2, 2, 2, 2, 679, 3, 2, 2, 2, 2, 681, 3, 2, 2, 2, 2, 683, 3, 2, 2, 2, 2, 685, 3, 2, 2, 2, 2, 687, 3, 2, 2, 2, 2, 689, 3, 2, 2, 2, 2, 691, 3, 2, 2, 2, 2, 693, 3, 2, 2, 2, 2, 695, 3, 2, 2, 2, 2, 697, 3, 2, 2, 2, 2, 699, 3, 2, 2, 2, 2, 701, 3, 2, 2, 2, 2, 703, 3, 2, 2, 2, 2, 705, 3, 2, 2, 2, 2, 707, 3, 2, 2, 2, 2, 709, 3, 2, 2, 2, 2, 711, 3, 2, 2, 2, 2, 713, 3, 2, 2, 2, 2, 715, 3, 2, 2, 2, 2, 717, 3, 2, 2, 2, 2, 719, 3, 2, 2, 2, 2, 721, 3, 2, 2, 2, 2, 723, 3, 2, 2, 2, 2, 725, 3, 2, 2, 2, 2, 727, 3, 2, 2, 2, 2, 729, 3, 2, 2, 2, 2, 731, 3, 2, 2, 2, 2, 733, 3, 2, 2, 2, 2, 735, 3, 2, 2, 2, 2, 737, 3, 2, 2, 2, 2, 739, 3, 2, 2, 2, 2, 741, 3, 2, 2, 2, 2, 743, 3, 2, 2, 2, 2, 745, 3, 2, 2, 2, 2, 747, 3, 2, 2, 2, 2, 749, 3, 2, 2, 2, 2, 751, 3, 2, 2, 2, 2, 753, 3, 2, 2, 2, 2, 755, 3, 2, 2, 2, 2, 757, 3, 2, 2, 2, 2, 759, 3, 2, 2, 2, 2, 761, 3, 2, 2, 2, 2, 763, 3, 2, 2, 2, 2, 765, 3, 2, 2, 2, 2, 767, 3, 2, 2, 2, 2, 769, 3, 2, 2, 2, 2, 771, 3, 2, 2, 2, 2, 773, 3, 2, 2, 2, 2, 775, 3, 2, 2, 2, 2, 777, 3, 2, 2, 2, 2, 779, 3, 2, 2, 2, 2, 781, 3, 2, 2, 2, 2, 783, 3, 2, 2, 2, 2, 785, 3, 2, 2, 2, 2, 787, 3, 2, 2, 2, 2, 789, 3, 2, 2, 2, 2, 791, 3, 2, 2, 2, 2, 793, 3, 2, 2, 2, 2, 795, 3, 2, 2, 2, 2, 797, 3, 2, 2, 2, 2, 799, 3, 2, 2, 2, 2, 801, 3, 2, 2, 2, 2, 803, 3, 2, 2, 2, 2, 805, 3, 2, 2, 2, 2, 807, 3, 2, 2, 2, 2, 809, 3, 2, 2, 2, 2, 811, 3, 2, 2, 2, 2, 813, 3, 2, 2, 2, 2, 815, 3, 2, 2, 2, 2, 817, 3, 2, 2, 2, 2, 819, 3, 2, 2, 2, 2, 821, 3, 2, 2, 2, 2, 823, 3, 2, 2, 2, 2, 825, 3, 2, 2, 2, 2, 827, 3, 2, 2, 2, 2, 829, 3, 2, 2, 2, 2, 831, 3, 2, 2, 2, 2, 833, 3, 2, 2, 2, 2, 835, 3, 2, 2, 2, 2, 837, 3, 2, 2, 2, 2, 839, 3, 2, 2, 2, 2, 841, 3, 2, 2, 2, 2, 843, 3, 2, 2, 2, 2, 845, 3, 2, 2, 2, 2, 847, 3, 2, 2, 2, 2, 849, 3, 2, 2, 2, 2, 851, 3, 2, 2, 2, 2, 853, 3, 2, 2, 2, 2, 855, 3, 2, 2, 2, 2, 857, 3, 2, 2, 2, 2, 859, 3, 2, 2, 2, 2, 861, 3, 2, 2, 2, 2, 863, 3, 2, 2, 2, 2, 865, 3, 2, 2, 2, 2, 867, 3, 2, 2, 2, 2, 869, 3, 2, 2, 2, 2, 871, 3, 2, 2, 2, 2, 873, 3, 2, 2, 2, 2, 875, 3, 2, 2, 2, 2, 877, 3, 2, 2, 2, 2, 879, 3, 2, 2, 2, 2, 881, 3, 2, 2, 2, 2, 883, 3, 2, 2, 2, 2, 885, 3, 2, 2, 2, 2, 887, 3, 2, 2, 2, 2, 889, 3, 2, 2, 2, 2, 891, 3, 2, 2, 2, 2, 893, 3, 2, 2, 2, 2, 895, 3, 2, 2, 2, 2, 897, 3, 2, 2, 2, 2, 899, 3, 2, 2, 2, 2, 901, 3, 2, 2, 2, 2, 903, 3, 2, 2, 2, 2, 905, 3, 2, 2, 2, 2, 907, 3, 2, 2, 2, 2, 909, 3, 2, 2, 2, 2, 911, 3, 2, 2, 2, 2, 913, 3, 2, 2, 2, 2, 915, 3, 2, 2, 2, 2, 917, 3, 2, 2, 2, 2, 919, 3, 2, 2, 2, 2, 921, 3, 2, 2, 2, 2, 923, 3, 2, 2, 2, 2, 925, 3, 2, 2, 2, 2, 927, 3, 2, 2, 2, 2, 929, 3, 2, 2, 2, 2, 931, 3, 2, 2, 2, 2, 933, 3, 2, 2, 2, 2, 935, 3, 2, 2, 2, 2, 937, 3, 2, 2, 2, 2, 939, 3, 2, 2, 2, 2, 941, 3, 2, 2, 2, 2, 943, 3, 2, 2, 2, 2, 945, 3, 2, 2, 2, 2, 947, 3, 2, 2, 2, 2, 949, 3, 2, 2, 2, 2, 951, 3, 2, 2, 2, 2, 953, 3, 2, 2, 2, 2, 955, 3, 2, 2, 2, 2, 957, 3, 2, 2, 2, 2, 959, 3, 2, 2, 2, 2, 961, 3, 2, 2, 2, 2, 963, 3, 2, 2, 2, 2, 965, 3, 2, 2, 2, 2, 967, 3, 2, 2, 2, 2, 969, 3, 2, 2, 2, 2, 971, 3, 2, 2, 2, 2, 973, 3, 2, 2, 2, 2, 975, 3, 2, 2, 2, 2, 977, 3, 2, 2, 2, 2, 979, 3, 2, 2, 2, 2, 981, 3, 2, 2, 2, 2, 983, 3, 2, 2, 2, 2, 985, 3, 2, 2, 2, 2, 987, 3, 2, 2, 2, 2, 989, 3, 2, 2, 2, 2, 991, 3, 2, 2, 2, 2, 993, 3, 2, 2, 2, 2, 995, 3, 2, 2, 2, 2, 997, 3, 2, 2, 2, 2, 999, 3, 2, 2, 2, 2, 1001, 3, 2, 2, 2, 2, 1003, 3, 2, 2, 2, 2, 1005, 3, 2, 2, 2, 2, 1007, 3, 2, 2, 2, 2, 1009, 3, 2, 2, 2, 2, 1011, 3, 2, 2, 2, 2, 1013, 3, 2, 2, 2, 2, 1015, 3, 2, 2, 2, 2, 1017, 3, 2, 2, 2, 2, 1019, 3, 2, 2, 2, 2, 1021, 3, 2, 2, 2, 2, 1023, 3, 2, 2, 2, 2, 1025, 3, 2, 2, 2, 2, 1027, 3, 2, 2, 2, 2, 1029, 3, 2, 2, 2, 2, 1031, 3, 2, 2, 2, 2, 1033, 3, 2, 2, 2, 2, 1035, 3, 2, 2, 2, 2, 1037, 3, 2, 2, 2, 2, 1045, 3, 2, 2, 2, 2, 1047, 3, 2, 2, 2, 2, 1049, 3, 2, 2, 2, 2, 1051, 3, 2, 2, 2, 2, 1053, 3, 2, 2, 2, 2, 1055, 3, 2, 2, 2, 2, 1057, 3, 2, 2, 2, 2, 1059, 3, 2, 2, 2, 2, 1061, 3, 2, 2, 2, 2, 1063, 3, 2, 2, 2, 2, 1065, 3, 2, 2, 2, 2, 1067, 3, 2, 2, 2, 2, 1069, 3, 2, 2, 2, 2, 1071, 3, 2, 2, 2, 2, 1075, 3, 2, 2, 2, 2, 1077, 3, 2, 2, 2, 2, 1079, 3, 2, 2, 2, 2, 1081, 3, 2, 2, 2, 2, 1083, 3, 2, 2, 2, 2, 1085, 3, 2, 2, 2, 2, 1087, 3, 2, 2, 2, 2, 1089, 3, 2, 2, 2, 2, 1091, 3, 2, 2, 2, 2, 1093, 3, 2, 2, 2, 2, 1095, 3, 2, 2, 2, 2, 1099, 3, 2, 2, 2, 2, 1101, 3, 2, 2, 2, 2, 1103, 3, 2, 2, 2, 2, 1105, 3, 2, 2, 2, 2, 1107, 3, 2, 2, 2, 2, 1109, 3, 2, 2, 2, 2, 1111, 3, 2, 2, 2, 2, 1113, 3, 2, 2, 2, 2, 1115, 3, 2, 2, 2, 2, 1117, 3, 2, 2, 2, 3, 1119, 3, 2, 2, 2, 3, 1121, 3, 2, 2, 2, 3, 1125, 3, 2, 2, 2, 3, 1127, 3, 2, 2, 2, 4, 1131, 3, 2, 2, 2, 4, 1133, 3, 2, 2, 2, 4, 1135, 3, 2, 2, 2, 5, 1137, 3, 2, 2, 2, 5, 1139, 3, 2, 2, 2, 5, 1141, 3, 2, 2, 2, 5, 1143, 3, 2, 2, 2, 6, 1145, 3, 2, 2, 2, 6, 1147, 3, 2, 2, 2, 7, 1149, 3, 2, 2, 2, 9, 1151, 3, 2, 2, 2, 11, 1153, 3, 2, 2, 2, 13, 1155, 3, 2, 2, 2, 15, 1157, 3, 2, 2, 2, 17, 1159, 3, 2, 2, 2, 19, 1161, 3, 2, 2, 2, 21, 1163, 3, 2, 2, 2, 23, 1165, 3, 2, 2, 2, 25, 1167, 3, 2, 2, 2, 27, 1169, 3, 2, 2, 2, 29, 1171, 3, 2, 2, 2, 31, 1173, 3, 2, 2, 2, 33, 1175, 3, 2, 2, 2, 35, 1177, 3, 2, 2, 2, 37, 1179, 3, 2, 2, 2, 39, 1181, 3, 2, 2, 2, 41, 1183, 3, 2, 2, 2, 43, 1186, 3, 2, 2, 2, 45, 1189, 3, 2, 2, 2, 47, 1192, 3, 2, 2, 2, 49, 1195, 3, 2, 2, 2, 51, 1198, 3, 2, 2, 2, 53, 1201, 3, 2, 2, 2, 55, 1204, 3, 2, 2, 2, 57, 1207, 3, 2, 2, 2, 59, 1210, 3, 2, 2, 2, 61, 1212, 3, 2, 2, 2, 63, 1238, 3, 2, 2, 2, 65, 1249, 3, 2, 2, 2, 67, 1265, 3, 2, 2, 2, 69, 1267, 3, 2, 2, 2, 71, 1269, 3, 2, 2, 2, 73, 1271, 3, 2, 2, 2, 75, 1275, 3, 2, 2, 2, 77, 1283, 3, 2, 2, 2, 79, 1291, 3, 2, 2, 2, 81, 1295, 3, 2, 2, 2, 83, 1299, 3, 2, 2, 2, 85, 1305, 3, 2, 2, 2, 87, 1308, 3, 2, 2, 2, 89, 1312, 3, 2, 2, 2, 91, 1323, 3, 2, 2, 2, 93, 1328, 3, 2, 2, 2, 95, 1333, 3, 2, 2, 2, 97, 1338, 3, 2, 2, 2, 99, 1344, 3, 2, 2, 2, 101, 1352, 3, 2, 2, 2, 103, 1359, 3, 2, 2, 2, 105, 1370, 3, 2, 2, 2, 107, 1377, 3, 2, 2, 2, 109, 1393, 3, 2, 2, 2, 111, 1406, 3, 2, 2, 2, 113, 1419, 3, 2, 2, 2, 115, 1432, 3, 2, 2, 2, 117, 1450, 3, 2, 2, 2, 119, 1463, 3, 2, 2, 2, 121, 1471, 3, 2, 2, 2, 123, 1482, 3, 2, 2, 2, 125, 1487, 3, 2, 2, 2, 127, 1496, 3, 2, 2, 2, 129, 1499, 3, 2, 2, 2, 131, 1504, 3, 2, 2, 2, 133, 1511, 3, 2, 2, 2, 135, 1517, 3, 2, 2, 2, 137, 1523, 3, 2, 2, 2, 139, 1527, 3, 2, 2, 2, 141, 1535, 3, 2, 2, 2, 143, 1540, 3, 2, 2, 2, 145, 1546, 3, 2, 2, 2, 147, 1552, 3, 2, 2, 2, 149, 1559, 3, 2, 2, 2, 151, 1562, 3, 2, 2, 2, 153, 1572, 3, 2, 2, 2, 155, 1582, 3, 2, 2, 2, 157, 1587, 3, 2, 2, 2, 159, 1595, 3, 2, 2, 2, 161, 1603, 3, 2, 2, 2, 163, 1609, 3, 2, 2, 2, 165, 1619, 3, 2, 2, 2, 167, 1634, 3, 2, 2, 2, 169, 1638, 3, 2, 2, 2, 171, 1643, 3, 2, 2, 2, 173, 1650, 3, 2, 2, 2, 175, 1653, 3, 2, 2, 2, 177, 1658, 3, 2, 2, 2, 179, 1661, 3, 2, 2, 2, 181, 1667, 3, 2, 2, 2, 183, 1675, 3, 2, 2, 2, 185, 1683, 3, 2, 2, 2, 187, 1694, 3, 2, 2, 2, 189, 1704, 3, 2, 2, 2, 191, 1711, 3, 2, 2, 2, 193, 1724, 3, 2, 2, 2, 195, 1729, 3, 2, 2, 2, 197, 1739, 3, 2, 2, 2, 199, 1745, 3, 2, 2, 2, 201, 1750, 3, 2, 2, 2, 203, 1753, 3, 2, 2, 2, 205, 1762, 3, 2, 2, 2, 207, 1767, 3, 2, 2, 2, 209, 1773, 3, 2, 2, 2, 211, 1780, 3, 2, 2, 2, 213, 1785, 3, 2, 2, 2, 215, 1791, 3, 2, 2, 2, 217, 1800, 3, 2, 2, 2, 219, 1805, 3, 2, 2, 2, 221, 1811, 3, 2, 2, 2, 223, 1818, 3, 2, 2, 2, 225, 1823, 3, 2, 2, 2, 227, 1837, 3, 2, 2, 2, 229, 1844, 3, 2, 2, 2, 231, 1854, 3, 2, 2, 2, 233, 1867, 3, 2, 2, 2, 235, 1873, 3, 2, 2, 2, 237, 1888, 3, 2, 2, 2, 239, 1895, 3, 2, 2, 2, 241, 1900, 3, 2, 2, 2, 243, 1906, 3, 2, 2, 2, 245, 1912, 3, 2, 2, 2, 247, 1915, 3, 2, 2, 2, 249, 1922, 3, 2, 2, 2, 251, 1927, 3, 2, 2, 2, 253, 1932, 3, 2, 2, 2, 255, 1937, 3, 2, 2, 2, 257, 1945, 3, 2, 2, 2, 259, 1953, 3, 2, 2, 2, 261, 1959, 3, 2, 2, 2, 263, 1964, 3, 2, 2, 2, 265, 1973, 3, 2, 2, 2, 267, 1979, 3, 2, 2, 2, 269, 1987, 3, 2, 2, 2, 271, 1995, 3, 2, 2, 2, 273, 2001, 3, 2, 2, 2, 275, 2010, 3, 2, 2, 2, 277, 2017, 3, 2, 2, 2, 279, 2024, 3, 2, 2, 2, 281, 2028, 3, 2, 2, 2, 283, 2034, 3, 2, 2, 2, 285, 2040, 3, 2, 2, 2, 287, 2050, 3, 2, 2, 2, 289, 2055, 3, 2, 2, 2, 291, 2061, 3, 2, 2, 2, 293, 2068, 3, 2, 2, 2, 295, 2078, 3, 2, 2, 2, 297, 2089, 3, 2, 2, 2, 299, 2092, 3, 2, 2, 2, 301, 2102, 3, 2, 2, 2, 303, 2111, 3, 2, 2, 2, 305, 2118, 3, 2, 2, 2, 307, 2124, 3, 2, 2, 2, 309, 2127, 3, 2, 2, 2, 311, 2133, 3, 2, 2, 2, 313, 2140, 3, 2, 2, 2, 315, 2148, 3, 2, 2, 2, 317, 2157, 3, 2, 2, 2, 319, 2165, 3, 2, 2, 2, 321, 2171, 3, 2, 2, 2, 323, 2187, 3, 2, 2, 2, 325, 2198, 3, 2, 2, 2, 327, 2204, 3, 2, 2, 2, 329, 2210, 3, 2, 2, 2, 331, 2218, 3, 2, 2, 2, 333, 2226, 3, 2, 2, 2, 335, 2235, 3, 2, 2, 2, 337, 2242, 3, 2, 2, 2, 339, 2252, 3, 2, 2, 2, 341, 2266, 3, 2, 2, 2, 343, 2277, 3, 2, 2, 2, 345, 2289, 3, 2, 2, 2, 347, 2297, 3, 2, 2, 2, 349, 2306, 3, 2, 2, 2, 351, 2317, 3, 2, 2, 2, 353, 2322, 3, 2, 2, 2, 355, 2327, 3, 2, 2, 2, 357, 2331, 3, 2, 2, 2, 359, 2338, 3, 2, 2, 2, 361, 2344, 3, 2, 2, 2, 363, 2349, 3, 2, 2, 2, 365, 2358, 3, 2, 2, 2, 367, 2362, 3, 2, 2, 2, 369, 2373, 3, 2, 2, 2, 371, 2381, 3, 2, 2, 2, 373, 2390, 3, 2, 2, 2, 375, 2399, 3, 2, 2, 2, 377, 2407, 3, 2, 2, 2, 379, 2414, 3, 2, 2, 2, 381, 2424, 3, 2, 2, 2, 383, 2435, 3, 2, 2, 2, 385, 2446, 3, 2, 2, 2, 387, 2454, 3, 2, 2, 2, 389, 2462, 3, 2, 2, 2, 391, 2471, 3, 2, 2, 2, 393, 2478, 3, 2, 2, 2, 395, 2485, 3, 2, 2, 2, 397, 2490, 3, 2, 2, 2, 399, 2495, 3, 2, 2, 2, 401, 2502, 3, 2, 2, 2, 403, 2511, 3, 2, 2, 2, 405, 2521, 3, 2, 2, 2, 407, 2526, 3, 2, 2, 2, 409, 2533, 3, 2, 2, 2, 411, 2539, 3, 2, 2, 2, 413, 2547, 3, 2, 2, 2, 415, 2557, 3, 2, 2, 2, 417, 2567, 3, 2, 2, 2, 419, 2575, 3, 2, 2, 2, 421, 2583, 3, 2, 2, 2, 423, 2593, 3, 2, 2, 2, 425, 2602, 3, 2, 2, 2, 427, 2609, 3, 2, 2, 2, 429, 2615, 3, 2, 2, 2, 431, 2625, 3, 2, 2, 2, 433, 2631, 3, 2, 2, 2, 435, 2639, 3, 2, 2, 2, 437, 2648, 3, 2, 2, 2, 439, 2658, 3, 2, 2, 2, 441, 2665, 3, 2, 2, 2, 443, 2673, 3, 2, 2, 2, 445, 2681, 3, 2, 2, 2, 447, 2688, 3, 2, 2, 2, 449, 2693, 3, 2, 2, 2, 451, 2698, 3, 2, 2, 2, 453, 2707, 3, 2, 2, 2, 455, 2710, 3, 2, 2, 2, 457, 2720, 3, 2, 2, 2, 459, 2730, 3, 2, 2, 2, 461, 2739, 3, 2, 2, 2, 463, 2749, 3, 2, 2, 2, 465, 2759, 3, 2, 2, 2, 467, 2765, 3, 2, 2, 2, 469, 2773, 3, 2, 2, 2, 471, 2781, 3, 2, 2, 2, 473, 2790, 3, 2, 2, 2, 475, 2797, 3, 2, 2, 2, 477, 2809, 3, 2, 2, 2, 479, 2816, 3, 2, 2, 2, 481, 2824, 3, 2, 2, 2, 483, 2832, 3, 2, 2, 2, 485, 2842, 3, 2, 2, 2, 487, 2846, 3, 2, 2, 2, 489, 2852, 3, 2, 2, 2, 491, 2861, 3, 2, 2, 2, 493, 2867, 3, 2, 2, 2, 495, 2872, 3, 2, 2, 2, 497, 2882, 3, 2, 2, 2, 499, 2888, 3, 2, 2, 2, 501, 2895, 3, 2, 2, 2, 503, 2900, 3, 2, 2, 2, 505, 2906, 3, 2, 2, 2, 507, 2915, 3, 2, 2, 2, 509, 2920, 3, 2, 2, 2, 511, 2928, 3, 2, 2, 2, 513, 2934, 3, 2, 2, 2, 515, 2947, 3, 2, 2, 2, 517, 2956, 3, 2, 2, 2, 519, 2963, 3, 2, 2, 2, 521, 2972, 3, 2, 2, 2, 523, 2977, 3, 2, 2, 2, 525, 2983, 3, 2, 2, 2, 527, 2988, 3, 2, 2, 2, 529, 2993, 3, 2, 2, 2, 531, 2999, 3, 2, 2, 2, 533, 3004, 3, 2, 2, 2, 535, 3007, 3, 2, 2, 2, 537, 3015, 3, 2, 2, 2, 539, 3022, 3, 2, 2, 2, 541, 3029, 3, 2, 2, 2, 543, 3035, 3, 2, 2, 2, 545, 3042, 3, 2, 2, 2, 547, 3045, 3, 2, 2, 2, 549, 3049, 3, 2, 2, 2, 551, 3054, 3, 2, 2, 2, 553, 3063, 3, 2, 2, 2, 555, 3070, 3, 2, 2, 2, 557, 3078, 3, 2, 2, 2, 559, 3084, 3, 2, 2, 2, 561, 3090, 3, 2, 2, 2, 563, 3097, 3, 2, 2, 2, 565, 3105, 3, 2, 2, 2, 567, 3115, 3, 2, 2, 2, 569, 3123, 3, 2, 2, 2, 571, 3132, 3, 2, 2, 2, 573, 3138, 3, 2, 2, 2, 575, 3148, 3, 2, 2, 2, 577, 3156, 3, 2, 2, 2, 579, 3165, 3, 2, 2, 2, 581, 3174, 3, 2, 2, 2, 583, 3180, 3, 2, 2, 2, 585, 3191, 3, 2, 2, 2, 587, 3202, 3, 2, 2, 2, 589, 3212, 3, 2, 2, 2, 591, 3220, 3, 2, 2, 2, 593, 3226, 3, 2, 2, 2, 595, 3232, 3, 2, 2, 2, 597, 3237, 3, 2, 2, 2, 599, 3246, 3, 2, 2, 2, 601, 3254, 3, 2, 2, 2, 603, 3264, 3, 2, 2, 2, 605, 3268, 3, 2, 2, 2, 607, 3276, 3, 2, 2, 2, 609, 3284, 3, 2, 2, 2, 611, 3293, 3, 2, 2, 2, 613, 3301, 3, 2, 2, 2, 615, 3308, 3, 2, 2, 2, 617, 3319, 3, 2, 2, 2, 619, 3327, 3, 2, 2, 2, 621, 3335, 3, 2, 2, 2, 623, 3341, 3, 2, 2, 2, 625, 3349, 3, 2, 2, 2, 627, 3358, 3, 2, 2, 2, 629, 3366, 3, 2, 2, 2, 631, 3373, 3, 2, 2, 2, 633, 3378, 3, 2, 2, 2, 635, 3387, 3, 2, 2, 2, 637, 3392, 3, 2, 2, 2, 639, 3397, 3, 2, 2, 2, 641, 3407, 3, 2, 2, 2, 643, 3414, 3, 2, 2, 2, 645, 3421, 3, 2, 2, 2, 647, 3428, 3, 2, 2, 2, 649, 3435, 3, 2, 2, 2, 651, 3444, 3, 2, 2, 2, 653, 3453, 3, 2, 2, 2, 655, 3463, 3, 2, 2, 2, 657, 3476, 3, 2, 2, 2, 659, 3483, 3, 2, 2, 2, 661, 3491, 3, 2, 2, 2, 663, 3495, 3, 2, 2, 2, 665, 3501, 3, 2, 2, 2, 667, 3506, 3, 2, 2, 2, 669, 3513, 3, 2, 2, 2, 671, 3522, 3, 2, 2, 2, 673, 3529, 3, 2, 2, 2, 675, 3540, 3, 2, 2, 2, 677, 3546, 3, 2, 2, 2, 679, 3556, 3, 2, 2, 2, 681, 3567, 3, 2, 2, 2, 683, 3573, 3, 2, 2, 2, 685, 3580, 3, 2, 2, 2, 687, 3588, 3, 2, 2, 2, 689, 3595, 3, 2, 2, 2, 691, 3601, 3, 2, 2, 2, 693, 3607, 3, 2, 2, 2, 695, 3614, 3, 2, 2, 2, 697, 3621, 3, 2, 2, 2, 699, 3632, 3, 2, 2, 2, 701, 3637, 3, 2, 2, 2, 703, 3646, 3, 2, 2, 2, 705, 3656, 3, 2, 2, 2, 707, 3661, 3, 2, 2, 2, 709, 3673, 3, 2, 2, 2, 711, 3681, 3, 2, 2, 2, 713, 3690, 3, 2, 2, 2, 715, 3698, 3, 2, 2, 2, 717, 3703, 3, 2, 2, 2, 719, 3709, 3, 2, 2, 2, 721, 3719, 3, 2, 2, 2, 723, 3731, 3, 2, 2, 2, 725, 3743, 3, 2, 2, 2, 727, 3751, 3, 2, 2, 2, 729, 3760, 3, 2, 2, 2, 731, 3769, 3, 2, 2, 2, 733, 3775, 3, 2, 2, 2, 735, 3782, 3, 2, 2, 2, 737, 3789, 3, 2, 2, 2, 739, 3795, 3, 2, 2, 2, 741, 3804, 3, 2, 2, 2, 743, 3814, 3, 2, 2, 2, 745, 3822, 3, 2, 2, 2, 747, 3830, 3, 2, 2, 2, 749, 3835, 3, 2, 2, 2, 751, 3844, 3, 2, 2, 2, 753, 3855, 3, 2, 2, 2, 755, 3863, 3, 2, 2, 2, 757, 3868, 3, 2, 2, 2, 759, 3876, 3, 2, 2, 2, 761, 3882, 3, 2, 2, 2, 763, 3886, 3, 2, 2, 2, 765, 3891, 3, 2, 2, 2, 767, 3895, 3, 2, 2, 2, 769, 3900, 3, 2, 2, 2, 771, 3908, 3, 2, 2, 2, 773, 3915, 3, 2, 2, 2, 775, 3919, 3, 2, 2, 2, 777, 3927, 3, 2, 2, 2, 779, 3932, 3, 2, 2, 2, 781, 3942, 3, 2, 2, 2, 783, 3951, 3, 2, 2, 2, 785, 3955, 3, 2, 2, 2, 787, 3963, 3, 2, 2, 2, 789, 3970, 3, 2, 2, 2, 791, 3978, 3, 2, 2, 2, 793, 3984, 3, 2, 2, 2, 795, 3993, 3, 2, 2, 2, 797, 3999, 3, 2, 2, 2, 799, 4003, 3, 2, 2, 2, 801, 4011, 3, 2, 2, 2, 803, 4020, 3, 2, 2, 2, 805, 4026, 3, 2, 2, 2, 807, 4035, 3, 2, 2, 2, 809, 4041, 3, 2, 2, 2, 811, 4046, 3, 2, 2, 2, 813, 4053, 3, 2, 2, 2, 815, 4061, 3, 2, 2, 2, 817, 4069, 3, 2, 2, 2, 819, 4078, 3, 2, 2, 2, 821, 4088, 3, 2, 2, 2, 823, 4093, 3, 2, 2, 2, 825, 4097, 3, 2, 2, 2, 827, 4103, 3, 2, 2, 2, 829, 4112, 3, 2, 2, 2, 831, 4122, 3, 2, 2, 2, 833, 4127, 3, 2, 2, 2, 835, 4137, 3, 2, 2, 2, 837, 4143, 3, 2, 2, 2, 839, 4148, 3, 2, 2, 2, 841, 4155, 3, 2, 2, 2, 843, 4163, 3, 2, 2, 2, 845, 4177, 3, 2, 2, 2, 847, 4187, 3, 2, 2, 2, 849, 4198, 3, 2, 2, 2, 851, 4208, 3, 2, 2, 2, 853, 4218, 3, 2, 2, 2, 855, 4227, 3, 2, 2, 2, 857, 4233, 3, 2, 2, 2, 859, 4241, 3, 2, 2, 2, 861, 4254, 3, 2, 2, 2, 863, 4259, 3, 2, 2, 2, 865, 4267, 3, 2, 2, 2, 867, 4274, 3, 2, 2, 2, 869, 4281, 3, 2, 2, 2, 871, 4292, 3, 2, 2, 2, 873, 4302, 3, 2, 2, 2, 875, 4309, 3, 2, 2, 2, 877, 4316, 3, 2, 2, 2, 879, 4324, 3, 2, 2, 2, 881, 4332, 3, 2, 2, 2, 883, 4342, 3, 2, 2, 2, 885, 4349, 3, 2, 2, 2, 887, 4356, 3, 2, 2, 2, 889, 4363, 3, 2, 2, 2, 891, 4375, 3, 2, 2, 2, 893, 4379, 3, 2, 2, 2, 895, 4383, 3, 2, 2, 2, 897, 4389, 3, 2, 2, 2, 899, 4402, 3, 2, 2, 2, 901, 4414, 3, 2, 2, 2, 903, 4418, 3, 2, 2, 2, 905, 4422, 3, 2, 2, 2, 907, 4431, 3, 2, 2, 2, 909, 4439, 3, 2, 2, 2, 911, 4450, 3, 2, 2, 2, 913, 4456, 3, 2, 2, 2, 915, 4464, 3, 2, 2, 2, 917, 4473, 3, 2, 2, 2, 919, 4477, 3, 2, 2, 2, 921, 4485, 3, 2, 2, 2, 923, 4496, 3, 2, 2, 2, 925, 4505, 3, 2, 2, 2, 927, 4510, 3, 2, 2, 2, 929, 4517, 3, 2, 2, 2, 931, 4522, 3, 2, 2, 2, 933, 4529, 3, 2, 2, 2, 935, 4534, 3, 2, 2, 2, 937, 4543, 3, 2, 2, 2, 939, 4548, 3, 2, 2, 2, 941, 4560, 3, 2, 2, 2, 943, 4571, 3, 2, 2, 2, 945, 4580, 3, 2, 2, 2, 947, 4588, 3, 2, 2, 2, 949, 4602, 3, 2, 2, 2, 951, 4610, 3, 2, 2, 2, 953, 4621, 3, 2, 2, 2, 955, 4628, 3, 2, 2, 2, 957, 4635, 3, 2, 2, 2, 959, 4642, 3, 2, 2, 2, 961, 4649, 3, 2, 2, 2, 963, 4653, 3, 2, 2, 2, 965, 4657, 3, 2, 2, 2, 967, 4662, 3, 2, 2, 2, 969, 4667, 3, 2, 2, 2, 971, 4675, 3, 2, 2, 2, 973, 4681, 3, 2, 2, 2, 975, 4691, 3, 2, 2, 2, 977, 4696, 3, 2, 2, 2, 979, 4716, 3, 2, 2, 2, 981, 4734, 3, 2, 2, 2, 983, 4740, 3, 2, 2, 2, 985, 4753, 3, 2, 2, 2, 987, 4764, 3, 2, 2, 2, 989, 4770, 3, 2, 2, 2, 991, 4779, 3, 2, 2, 2, 993, 4787, 3, 2, 2, 2, 995, 4791, 3, 2, 2, 2, 997, 4803, 3, 2, 2, 2, 999, 4811, 3, 2, 2, 2, 1001, 4817, 3, 2, 2, 2, 1003, 4823, 3, 2, 2, 2, 1005, 4831, 3, 2, 2, 2, 1007, 4839, 3, 2, 2, 2, 1009, 4845, 3, 2, 2, 2, 1011, 4850, 3, 2, 2, 2, 1013, 4857, 3, 2, 2, 2, 1015, 4863, 3, 2, 2, 2, 1017, 4869, 3, 2, 2, 2, 1019, 4878, 3, 2, 2, 2, 1021, 4884, 3, 2, 2, 2, 1023, 4888, 3, 2, 2, 2, 1025, 4893, 3, 2, 2, 2, 1027, 4900, 3, 2, 2, 2, 1029, 4908, 3, 2, 2, 2, 1031, 4918, 3, 2, 2, 2, 1033, 4925, 3, 2, 2, 2, 1035, 4930, 3, 2, 2, 2, 1037, 4935, 3, 2, 2, 2, 1039, 4948, 3, 2, 2, 2, 1041, 4952, 3, 2, 2, 2, 1043, 4956, 3, 2, 2, 2, 1045, 4958, 3, 2, 2, 2, 1047, 4961, 3, 2, 2, 2, 1049, 4970, 3, 2, 2, 2, 1051, 4973, 3, 2, 2, 2, 1053, 4982, 3, 2, 2, 2, 1055, 4986, 3, 2, 2, 2, 1057, 4990, 3, 2, 2, 2, 1059, 4994, 3, 2, 2, 2, 1061, 4998, 3, 2, 2, 2, 1063, 5001, 3, 2, 2, 2, 1065, 5010, 3, 2, 2, 2, 1067, 5016, 3, 2, 2, 2, 1069, 5019, 3, 2, 2, 2, 1071, 5023, 3, 2, 2, 2, 1073, 5032, 3, 2, 2, 2, 1075, 5039, 3, 2, 2, 2, 1077, 5042, 3, 2, 2, 2, 1079, 5050, 3, 2, 2, 2, 1081, 5053, 3, 2, 2, 2, 1083, 5056, 3, 2, 2, 2, 1085, 5059, 3, 2, 2, 2, 1087, 5067, 3, 2, 2, 2, 1089, 5070, 3, 2, 2, 2, 1091, 5073, 3, 2, 2, 2, 1093, 5075, 3, 2, 2, 2, 1095, 5109, 3, 2, 2, 2, 1097, 5112, 3, 2, 2, 2, 1099, 5116, 3, 2, 2, 2, 1101, 5124, 3, 2, 2, 2, 1103, 5140, 3, 2, 2, 2, 1105, 5151, 3, 2, 2, 2, 1107, 5155, 3, 2, 2, 2, 1109, 5166, 3, 2, 2, 2, 1111, 5205, 3, 2, 2, 2, 1113, 5256, 3, 2, 2, 2, 1115, 5280, 3, 2, 2, 2, 1117, 5283, 3, 2, 2, 2, 1119, 5285, 3, 2, 2, 2, 1121, 5290, 3, 2, 2, 2, 1123, 5321, 3, 2, 2, 2, 1125, 5324, 3, 2, 2, 2, 1127, 5329, 3, 2, 2, 2, 1129, 5342, 3, 2, 2, 2, 1131, 5345, 3, 2, 2, 2, 1133, 5350, 3, 2, 2, 2, 1135, 5356, 3, 2, 2, 2, 1137, 5361, 3, 2, 2, 2, 1139, 5366, 3, 2, 2, 2, 1141, 5371, 3, 2, 2, 2, 1143, 5376, 3, 2, 2, 2, 1145, 5393, 3, 2, 2, 2, 1147, 5395, 3, 2, 2, 2, 1149, 1150, 7, 38, 2, 2, 1150, 8, 3, 2, 2, 2, 1151, 1152, 7, 42, 2, 2, 1152, 10, 3, 2, 2, 2, 1153, 1154, 7, 43, 2, 2, 1154, 12, 3, 2, 2, 2, 1155, 1156, 7, 93, 2, 2, 1156, 14, 3, 2, 2, 2, 1157, 1158, 7, 95, 2, 2, 1158, 16, 3, 2, 2, 2, 1159, 1160, 7, 46, 2, 2, 1160, 18, 3, 2, 2, 2, 1161, 1162, 7, 61, 2, 2, 1162, 20, 3, 2, 2, 2, 1163, 1164, 7, 60, 2, 2, 1164, 22, 3, 2, 2, 2, 1165, 1166, 7, 44, 2, 2, 1166, 24, 3, 2, 2, 2, 1167, 1168, 7, 63, 2, 2, 1168, 26, 3, 2, 2, 2, 1169, 1170, 7, 48, 2, 2, 1170, 28, 3, 2, 2, 2, 1171, 1172, 7, 45, 2, 2, 1172, 30, 3, 2, 2, 2, 1173, 1174, 7, 47, 2, 2, 1174, 32, 3, 2, 2, 2, 1175, 1176, 7, 49, 2, 2, 1176, 34, 3, 2, 2, 2, 1177, 1178, 7, 96, 2, 2, 1178, 36, 3, 2, 2, 2, 1179, 1180, 7, 62, 2, 2, 1180, 38, 3, 2, 2, 2, 1181, 1182, 7, 64, 2, 2, 1182, 40, 3, 2, 2, 2, 1183, 1184, 7, 62, 2, 2, 1184, 1185, 7, 62, 2, 2, 1185, 42, 3, 2, 2, 2, 1186, 1187, 7, 64, 2, 2, 1187, 1188, 7, 64, 2, 2, 1188, 44, 3, 2, 2, 2, 1189, 1190, 7, 60, 2, 2, 1190, 1191, 7, 63, 2, 2, 1191, 46, 3, 2, 2, 2, 1192, 1193, 7, 62, 2, 2, 1193, 1194, 7, 63, 2, 2, 1194, 48, 3, 2, 2, 2, 1195, 1196, 7, 63, 2, 2, 1196, 1197, 7, 64, 2, 2, 1197, 50, 3, 2, 2, 2, 1198, 1199, 7, 64, 2, 2, 1199, 1200, 7, 63, 2, 2, 1200, 52, 3, 2, 2, 2, 1201, 1202, 7, 48, 2, 2, 1202, 1203, 7, 48, 2, 2, 1203, 54, 3, 2, 2, 2, 1204, 1205, 7, 62, 2, 2, 1205, 1206, 7, 64, 2, 2, 1206, 56, 3, 2, 2, 2, 1207, 1208, 7, 60, 2, 2, 1208, 1209, 7, 60, 2, 2, 1209, 58, 3, 2, 2, 2, 1210, 1211, 7, 39, 2, 2, 1211, 60, 3, 2, 2, 2, 1212, 1214, 7, 38, 2, 2, 1213, 1215, 9, 2, 2, 2, 1214, 1213, 3, 2, 2, 2, 1215, 1216, 3, 2, 2, 2, 1216, 1214, 3, 2, 2, 2, 1216, 1217, 3, 2, 2, 2, 1217, 62, 3, 2, 2, 2, 1218, 1234, 5, 67, 32, 2, 1219, 1223, 7, 45, 2, 2, 1220, 1221, 7, 47, 2, 2, 1221, 1223, 6, 30, 2, 2, 1222, 1219, 3, 2, 2, 2, 1222, 1220, 3, 2, 2, 2, 1223, 1224, 3, 2, 2, 2, 1224, 1222, 3, 2, 2, 2, 1224, 1225, 3, 2, 2, 2, 1225, 1229, 3, 2, 2, 2, 1226, 1230, 5, 67, 32, 2, 1227, 1228, 7, 49, 2, 2, 1228, 1230, 6, 30, 3, 2, 1229, 1226, 3, 2, 2, 2, 1229, 1227, 3, 2, 2, 2, 1230, 1234, 3, 2, 2, 2, 1231, 1232, 7, 49, 2, 2, 1232, 1234, 6, 30, 4, 2, 1233, 1218, 3, 2, 2, 2, 1233, 1222, 3, 2, 2, 2, 1233, 1231, 3, 2, 2, 2, 1234, 1235, 3, 2, 2, 2, 1235, 1233, 3, 2, 2, 2, 1235, 1236, 3, 2, 2, 2, 1236, 1239, 3, 2, 2, 2, 1237, 1239, 9, 3, 2, 2, 1238, 1233, 3, 2, 2, 2, 1238, 1237, 3, 2, 2, 2, 1239, 1240, 3, 2, 2, 2, 1240, 1241, 8, 30, 2, 2, 1241, 64, 3, 2, 2, 2, 1242, 1248, 5, 69, 33, 2, 1243, 1244, 7, 47, 2, 2, 1244, 1248, 6, 31, 5, 2, 1245, 1246, 7, 49, 2, 2, 1246, 1248, 6, 31, 6, 2, 1247, 1242, 3, 2, 2, 2, 1247, 1243, 3, 2, 2, 2, 1247, 1245, 3, 2, 2, 2, 1248, 1251, 3, 2, 2, 2, 1249, 1247, 3, 2, 2, 2, 1249, 1250, 3, 2, 2, 2, 1250, 1252, 3, 2, 2, 2, 1251, 1249, 3, 2, 2, 2, 1252, 1254, 5, 71, 34, 2, 1253, 1255, 5, 63, 30, 2, 1254, 1253, 3, 2, 2, 2, 1254, 1255, 3, 2, 2, 2, 1255, 1259, 3, 2, 2, 2, 1256, 1260, 7, 45, 2, 2, 1257, 1258, 7, 47, 2, 2, 1258, 1260, 6, 31, 7, 2, 1259, 1256, 3, 2, 2, 2, 1259, 1257, 3, 2, 2, 2, 1260, 1261, 3, 2, 2, 2, 1261, 1259, 3, 2, 2, 2, 1261, 1262, 3, 2, 2, 2, 1262, 1263, 3, 2, 2, 2, 1263, 1264, 8, 31, 3, 2, 1264, 66, 3, 2, 2, 2, 1265, 1266, 9, 4, 2, 2, 1266, 68, 3, 2, 2, 2, 1267, 1268, 9, 5, 2, 2, 1268, 70, 3, 2, 2, 2, 1269, 1270, 9, 6, 2, 2, 1270, 72, 3, 2, 2, 2, 1271, 1272, 7, 67, 2, 2, 1272, 1273, 7, 78, 2, 2, 1273, 1274, 7, 78, 2, 2, 1274, 74, 3, 2, 2, 2, 1275, 1276, 7, 67, 2, 2, 1276, 1277, 7, 80, 2, 2, 1277, 1278, 7, 67, 2, 2, 1278, 1279, 7, 78, 2, 2, 1279, 1280, 7, 91, 2, 2, 1280, 1281, 7, 85, 2, 2, 1281, 1282, 7, 71, 2, 2, 1282, 76, 3, 2, 2, 2, 1283, 1284, 7, 67, 2, 2, 1284, 1285, 7, 80, 2, 2, 1285, 1286, 7, 67, 2, 2, 1286, 1287, 7, 78, 2, 2, 1287, 1288, 7, 91, 2, 2, 1288, 1289, 7, 92, 2, 2, 1289, 1290, 7, 71, 2, 2, 1290, 78, 3, 2, 2, 2, 1291, 1292, 7, 67, 2, 2, 1292, 1293, 7, 80, 2, 2, 1293, 1294, 7, 70, 2, 2, 1294, 80, 3, 2, 2, 2, 1295, 1296, 7, 67, 2, 2, 1296, 1297, 7, 80, 2, 2, 1297, 1298, 7, 91, 2, 2, 1298, 82, 3, 2, 2, 2, 1299, 1300, 7, 67, 2, 2, 1300, 1301, 7, 84, 2, 2, 1301, 1302, 7, 84, 2, 2, 1302, 1303, 7, 67, 2, 2, 1303, 1304, 7, 91, 2, 2, 1304, 84, 3, 2, 2, 2, 1305, 1306, 7, 67, 2, 2, 1306, 1307, 7, 85, 2, 2, 1307, 86, 3, 2, 2, 2, 1308, 1309, 7, 67, 2, 2, 1309, 1310, 7, 85, 2, 2, 1310, 1311, 7, 69, 2, 2, 1311, 88, 3, 2, 2, 2, 1312, 1313, 7, 67, 2, 2, 1313, 1314, 7, 85, 2, 2, 1314, 1315, 7, 91, 2, 2, 1315, 1316, 7, 79, 2, 2, 1316, 1317, 7, 79, 2, 2, 1317, 1318, 7, 71, 2, 2, 1318, 1319, 7, 86, 2, 2, 1319, 1320, 7, 84, 2, 2, 1320, 1321, 7, 75, 2, 2, 1321, 1322, 7, 69, 2, 2, 1322, 90, 3, 2, 2, 2, 1323, 1324, 7, 68, 2, 2, 1324, 1325, 7, 81, 2, 2, 1325, 1326, 7, 86, 2, 2, 1326, 1327, 7, 74, 2, 2, 1327, 92, 3, 2, 2, 2, 1328, 1329, 7, 69, 2, 2, 1329, 1330, 7, 67, 2, 2, 1330, 1331, 7, 85, 2, 2, 1331, 1332, 7, 71, 2, 2, 1332, 94, 3, 2, 2, 2, 1333, 1334, 7, 69, 2, 2, 1334, 1335, 7, 67, 2, 2, 1335, 1336, 7, 85, 2, 2, 1336, 1337, 7, 86, 2, 2, 1337, 96, 3, 2, 2, 2, 1338, 1339, 7, 69, 2, 2, 1339, 1340, 7, 74, 2, 2, 1340, 1341, 7, 71, 2, 2, 1341, 1342, 7, 69, 2, 2, 1342, 1343, 7, 77, 2, 2, 1343, 98, 3, 2, 2, 2, 1344, 1345, 7, 69, 2, 2, 1345, 1346, 7, 81, 2, 2, 1346, 1347, 7, 78, 2, 2, 1347, 1348, 7, 78, 2, 2, 1348, 1349, 7, 67, 2, 2, 1349, 1350, 7, 86, 2, 2, 1350, 1351, 7, 71, 2, 2, 1351, 100, 3, 2, 2, 2, 1352, 1353, 7, 69, 2, 2, 1353, 1354, 7, 81, 2, 2, 1354, 1355, 7, 78, 2, 2, 1355, 1356, 7, 87, 2, 2, 1356, 1357, 7, 79, 2, 2, 1357, 1358, 7, 80, 2, 2, 1358, 102, 3, 2, 2, 2, 1359, 1360, 7, 69, 2, 2, 1360, 1361, 7, 81, 2, 2, 1361, 1362, 7, 80, 2, 2, 1362, 1363, 7, 85, 2, 2, 1363, 1364, 7, 86, 2, 2, 1364, 1365, 7, 84, 2, 2, 1365, 1366, 7, 67, 2, 2, 1366, 1367, 7, 75, 2, 2, 1367, 1368, 7, 80, 2, 2, 1368, 1369, 7, 86, 2, 2, 1369, 104, 3, 2, 2, 2, 1370, 1371, 7, 69, 2, 2, 1371, 1372, 7, 84, 2, 2, 1372, 1373, 7, 71, 2, 2, 1373, 1374, 7, 67, 2, 2, 1374, 1375, 7, 86, 2, 2, 1375, 1376, 7, 71, 2, 2, 1376, 106, 3, 2, 2, 2, 1377, 1378, 7, 69, 2, 2, 1378, 1379, 7, 87, 2, 2, 1379, 1380, 7, 84, 2, 2, 1380, 1381, 7, 84, 2, 2, 1381, 1382, 7, 71, 2, 2, 1382, 1383, 7, 80, 2, 2, 1383, 1384, 7, 86, 2, 2, 1384, 1385, 7, 97, 2, 2, 1385, 1386, 7, 69, 2, 2, 1386, 1387, 7, 67, 2, 2, 1387, 1388, 7, 86, 2, 2, 1388, 1389, 7, 67, 2, 2, 1389, 1390, 7, 78, 2, 2, 1390, 1391, 7, 81, 2, 2, 1391, 1392, 7, 73, 2, 2, 1392, 108, 3, 2, 2, 2, 1393, 1394, 7, 69, 2, 2, 1394, 1395, 7, 87, 2, 2, 1395, 1396, 7, 84, 2, 2, 1396, 1397, 7, 84, 2, 2, 1397, 1398, 7, 71, 2, 2, 1398, 1399, 7, 80, 2, 2, 1399, 1400, 7, 86, 2, 2, 1400, 1401, 7, 97, 2, 2, 1401, 1402, 7, 70, 2, 2, 1402, 1403, 7, 67, 2, 2, 1403, 1404, 7, 86, 2, 2, 1404, 1405, 7, 71, 2, 2, 1405, 110, 3, 2, 2, 2, 1406, 1407, 7, 69, 2, 2, 1407, 1408, 7, 87, 2, 2, 1408, 1409, 7, 84, 2, 2, 1409, 1410, 7, 84, 2, 2, 1410, 1411, 7, 71, 2, 2, 1411, 1412, 7, 80, 2, 2, 1412, 1413, 7, 86, 2, 2, 1413, 1414, 7, 97, 2, 2, 1414, 1415, 7, 84, 2, 2, 1415, 1416, 7, 81, 2, 2, 1416, 1417, 7, 78, 2, 2, 1417, 1418, 7, 71, 2, 2, 1418, 112, 3, 2, 2, 2, 1419, 1420, 7, 69, 2, 2, 1420, 1421, 7, 87, 2, 2, 1421, 1422, 7, 84, 2, 2, 1422, 1423, 7, 84, 2, 2, 1423, 1424, 7, 71, 2, 2, 1424, 1425, 7, 80, 2, 2, 1425, 1426, 7, 86, 2, 2, 1426, 1427, 7, 97, 2, 2, 1427, 1428, 7, 86, 2, 2, 1428, 1429, 7, 75, 2, 2, 1429, 1430, 7, 79, 2, 2, 1430, 1431, 7, 71, 2, 2, 1431, 114, 3, 2, 2, 2, 1432, 1433, 7, 69, 2, 2, 1433, 1434, 7, 87, 2, 2, 1434, 1435, 7, 84, 2, 2, 1435, 1436, 7, 84, 2, 2, 1436, 1437, 7, 71, 2, 2, 1437, 1438, 7, 80, 2, 2, 1438, 1439, 7, 86, 2, 2, 1439, 1440, 7, 97, 2, 2, 1440, 1441, 7, 86, 2, 2, 1441, 1442, 7, 75, 2, 2, 1442, 1443, 7, 79, 2, 2, 1443, 1444, 7, 71, 2, 2, 1444, 1445, 7, 85, 2, 2, 1445, 1446, 7, 86, 2, 2, 1446, 1447, 7, 67, 2, 2, 1447, 1448, 7, 79, 2, 2, 1448, 1449, 7, 82, 2, 2, 1449, 116, 3, 2, 2, 2, 1450, 1451, 7, 69, 2, 2, 1451, 1452, 7, 87, 2, 2, 1452, 1453, 7, 84, 2, 2, 1453, 1454, 7, 84, 2, 2, 1454, 1455, 7, 71, 2, 2, 1455, 1456, 7, 80, 2, 2, 1456, 1457, 7, 86, 2, 2, 1457, 1458, 7, 97, 2, 2, 1458, 1459, 7, 87, 2, 2, 1459, 1460, 7, 85, 2, 2, 1460, 1461, 7, 71, 2, 2, 1461, 1462, 7, 84, 2, 2, 1462, 118, 3, 2, 2, 2, 1463, 1464, 7, 70, 2, 2, 1464, 1465, 7, 71, 2, 2, 1465, 1466, 7, 72, 2, 2, 1466, 1467, 7, 67, 2, 2, 1467, 1468, 7, 87, 2, 2, 1468, 1469, 7, 78, 2, 2, 1469, 1470, 7, 86, 2, 2, 1470, 120, 3, 2, 2, 2, 1471, 1472, 7, 70, 2, 2, 1472, 1473, 7, 71, 2, 2, 1473, 1474, 7, 72, 2, 2, 1474, 1475, 7, 71, 2, 2, 1475, 1476, 7, 84, 2, 2, 1476, 1477, 7, 84, 2, 2, 1477, 1478, 7, 67, 2, 2, 1478, 1479, 7, 68, 2, 2, 1479, 1480, 7, 78, 2, 2, 1480, 1481, 7, 71, 2, 2, 1481, 122, 3, 2, 2, 2, 1482, 1483, 7, 70, 2, 2, 1483, 1484, 7, 71, 2, 2, 1484, 1485, 7, 85, 2, 2, 1485, 1486, 7, 69, 2, 2, 1486, 124, 3, 2, 2, 2, 1487, 1488, 7, 70, 2, 2, 1488, 1489, 7, 75, 2, 2, 1489, 1490, 7, 85, 2, 2, 1490, 1491, 7, 86, 2, 2, 1491, 1492, 7, 75, 2, 2, 1492, 1493, 7, 80, 2, 2, 1493, 1494, 7, 69, 2, 2, 1494, 1495, 7, 86, 2, 2, 1495, 126, 3, 2, 2, 2, 1496, 1497, 7, 70, 2, 2, 1497, 1498, 7, 81, 2, 2, 1498, 128, 3, 2, 2, 2, 1499, 1500, 7, 71, 2, 2, 1500, 1501, 7, 78, 2, 2, 1501, 1502, 7, 85, 2, 2, 1502, 1503, 7, 71, 2, 2, 1503, 130, 3, 2, 2, 2, 1504, 1505, 7, 71, 2, 2, 1505, 1506, 7, 90, 2, 2, 1506, 1507, 7, 69, 2, 2, 1507, 1508, 7, 71, 2, 2, 1508, 1509, 7, 82, 2, 2, 1509, 1510, 7, 86, 2, 2, 1510, 132, 3, 2, 2, 2, 1511, 1512, 7, 72, 2, 2, 1512, 1513, 7, 67, 2, 2, 1513, 1514, 7, 78, 2, 2, 1514, 1515, 7, 85, 2, 2, 1515, 1516, 7, 71, 2, 2, 1516, 134, 3, 2, 2, 2, 1517, 1518, 7, 72, 2, 2, 1518, 1519, 7, 71, 2, 2, 1519, 1520, 7, 86, 2, 2, 1520, 1521, 7, 69, 2, 2, 1521, 1522, 7, 74, 2, 2, 1522, 136, 3, 2, 2, 2, 1523, 1524, 7, 72, 2, 2, 1524, 1525, 7, 81, 2, 2, 1525, 1526, 7, 84, 2, 2, 1526, 138, 3, 2, 2, 2, 1527, 1528, 7, 72, 2, 2, 1528, 1529, 7, 81, 2, 2, 1529, 1530, 7, 84, 2, 2, 1530, 1531, 7, 71, 2, 2, 1531, 1532, 7, 75, 2, 2, 1532, 1533, 7, 73, 2, 2, 1533, 1534, 7, 80, 2, 2, 1534, 140, 3, 2, 2, 2, 1535, 1536, 7, 72, 2, 2, 1536, 1537, 7, 84, 2, 2, 1537, 1538, 7, 81, 2, 2, 1538, 1539, 7, 79, 2, 2, 1539, 142, 3, 2, 2, 2, 1540, 1541, 7, 73, 2, 2, 1541, 1542, 7, 84, 2, 2, 1542, 1543, 7, 67, 2, 2, 1543, 1544, 7, 80, 2, 2, 1544, 1545, 7, 86, 2, 2, 1545, 144, 3, 2, 2, 2, 1546, 1547, 7, 73, 2, 2, 1547, 1548, 7, 84, 2, 2, 1548, 1549, 7, 81, 2, 2, 1549, 1550, 7, 87, 2, 2, 1550, 1551, 7, 82, 2, 2, 1551, 146, 3, 2, 2, 2, 1552, 1553, 7, 74, 2, 2, 1553, 1554, 7, 67, 2, 2, 1554, 1555, 7, 88, 2, 2, 1555, 1556, 7, 75, 2, 2, 1556, 1557, 7, 80, 2, 2, 1557, 1558, 7, 73, 2, 2, 1558, 148, 3, 2, 2, 2, 1559, 1560, 7, 75, 2, 2, 1560, 1561, 7, 80, 2, 2, 1561, 150, 3, 2, 2, 2, 1562, 1563, 7, 75, 2, 2, 1563, 1564, 7, 80, 2, 2, 1564, 1565, 7, 75, 2, 2, 1565, 1566, 7, 86, 2, 2, 1566, 1567, 7, 75, 2, 2, 1567, 1568, 7, 67, 2, 2, 1568, 1569, 7, 78, 2, 2, 1569, 1570, 7, 78, 2, 2, 1570, 1571, 7, 91, 2, 2, 1571, 152, 3, 2, 2, 2, 1572, 1573, 7, 75, 2, 2, 1573, 1574, 7, 80, 2, 2, 1574, 1575, 7, 86, 2, 2, 1575, 1576, 7, 71, 2, 2, 1576, 1577, 7, 84, 2, 2, 1577, 1578, 7, 85, 2, 2, 1578, 1579, 7, 71, 2, 2, 1579, 1580, 7, 69, 2, 2, 1580, 1581, 7, 86, 2, 2, 1581, 154, 3, 2, 2, 2, 1582, 1583, 7, 75, 2, 2, 1583, 1584, 7, 80, 2, 2, 1584, 1585, 7, 86, 2, 2, 1585, 1586, 7, 81, 2, 2, 1586, 156, 3, 2, 2, 2, 1587, 1588, 7, 78, 2, 2, 1588, 1589, 7, 67, 2, 2, 1589, 1590, 7, 86, 2, 2, 1590, 1591, 7, 71, 2, 2, 1591, 1592, 7, 84, 2, 2, 1592, 1593, 7, 67, 2, 2, 1593, 1594, 7, 78, 2, 2, 1594, 158, 3, 2, 2, 2, 1595, 1596, 7, 78, 2, 2, 1596, 1597, 7, 71, 2, 2, 1597, 1598, 7, 67, 2, 2, 1598, 1599, 7, 70, 2, 2, 1599, 1600, 7, 75, 2, 2, 1600, 1601, 7, 80, 2, 2, 1601, 1602, 7, 73, 2, 2, 1602, 160, 3, 2, 2, 2, 1603, 1604, 7, 78, 2, 2, 1604, 1605, 7, 75, 2, 2, 1605, 1606, 7, 79, 2, 2, 1606, 1607, 7, 75, 2, 2, 1607, 1608, 7, 86, 2, 2, 1608, 162, 3, 2, 2, 2, 1609, 1610, 7, 78, 2, 2, 1610, 1611, 7, 81, 2, 2, 1611, 1612, 7, 69, 2, 2, 1612, 1613, 7, 67, 2, 2, 1613, 1614, 7, 78, 2, 2, 1614, 1615, 7, 86, 2, 2, 1615, 1616, 7, 75, 2, 2, 1616, 1617, 7, 79, 2, 2, 1617, 1618, 7, 71, 2, 2, 1618, 164, 3, 2, 2, 2, 1619, 1620, 7, 78, 2, 2, 1620, 1621, 7, 81, 2, 2, 1621, 1622, 7, 69, 2, 2, 1622, 1623, 7, 67, 2, 2, 1623, 1624, 7, 78, 2, 2, 1624, 1625, 7, 86, 2, 2, 1625, 1626, 7, 75, 2, 2, 1626, 1627, 7, 79, 2, 2, 1627, 1628, 7, 71, 2, 2, 1628, 1629, 7, 85, 2, 2, 1629, 1630, 7, 86, 2, 2, 1630, 1631, 7, 67, 2, 2, 1631, 1632, 7, 79, 2, 2, 1632, 1633, 7, 82, 2, 2, 1633, 166, 3, 2, 2, 2, 1634, 1635, 7, 80, 2, 2, 1635, 1636, 7, 81, 2, 2, 1636, 1637, 7, 86, 2, 2, 1637, 168, 3, 2, 2, 2, 1638, 1639, 7, 80, 2, 2, 1639, 1640, 7, 87, 2, 2, 1640, 1641, 7, 78, 2, 2, 1641, 1642, 7, 78, 2, 2, 1642, 170, 3, 2, 2, 2, 1643, 1644, 7, 81, 2, 2, 1644, 1645, 7, 72, 2, 2, 1645, 1646, 7, 72, 2, 2, 1646, 1647, 7, 85, 2, 2, 1647, 1648, 7, 71, 2, 2, 1648, 1649, 7, 86, 2, 2, 1649, 172, 3, 2, 2, 2, 1650, 1651, 7, 81, 2, 2, 1651, 1652, 7, 80, 2, 2, 1652, 174, 3, 2, 2, 2, 1653, 1654, 7, 81, 2, 2, 1654, 1655, 7, 80, 2, 2, 1655, 1656, 7, 78, 2, 2, 1656, 1657, 7, 91, 2, 2, 1657, 176, 3, 2, 2, 2, 1658, 1659, 7, 81, 2, 2, 1659, 1660, 7, 84, 2, 2, 1660, 178, 3, 2, 2, 2, 1661, 1662, 7, 81, 2, 2, 1662, 1663, 7, 84, 2, 2, 1663, 1664, 7, 70, 2, 2, 1664, 1665, 7, 71, 2, 2, 1665, 1666, 7, 84, 2, 2, 1666, 180, 3, 2, 2, 2, 1667, 1668, 7, 82, 2, 2, 1668, 1669, 7, 78, 2, 2, 1669, 1670, 7, 67, 2, 2, 1670, 1671, 7, 69, 2, 2, 1671, 1672, 7, 75, 2, 2, 1672, 1673, 7, 80, 2, 2, 1673, 1674, 7, 73, 2, 2, 1674, 182, 3, 2, 2, 2, 1675, 1676, 7, 82, 2, 2, 1676, 1677, 7, 84, 2, 2, 1677, 1678, 7, 75, 2, 2, 1678, 1679, 7, 79, 2, 2, 1679, 1680, 7, 67, 2, 2, 1680, 1681, 7, 84, 2, 2, 1681, 1682, 7, 91, 2, 2, 1682, 184, 3, 2, 2, 2, 1683, 1684, 7, 84, 2, 2, 1684, 1685, 7, 71, 2, 2, 1685, 1686, 7, 72, 2, 2, 1686, 1687, 7, 71, 2, 2, 1687, 1688, 7, 84, 2, 2, 1688, 1689, 7, 71, 2, 2, 1689, 1690, 7, 80, 2, 2, 1690, 1691, 7, 69, 2, 2, 1691, 1692, 7, 71, 2, 2, 1692, 1693, 7, 85, 2, 2, 1693, 186, 3, 2, 2, 2, 1694, 1695, 7, 84, 2, 2, 1695, 1696, 7, 71, 2, 2, 1696, 1697, 7, 86, 2, 2, 1697, 1698, 7, 87, 2, 2, 1698, 1699, 7, 84, 2, 2, 1699, 1700, 7, 80, 2, 2, 1700, 1701, 7, 75, 2, 2, 1701, 1702, 7, 80, 2, 2, 1702, 1703, 7, 73, 2, 2, 1703, 188, 3, 2, 2, 2, 1704, 1705, 7, 85, 2, 2, 1705, 1706, 7, 71, 2, 2, 1706, 1707, 7, 78, 2, 2, 1707, 1708, 7, 71, 2, 2, 1708, 1709, 7, 69, 2, 2, 1709, 1710, 7, 86, 2, 2, 1710, 190, 3, 2, 2, 2, 1711, 1712, 7, 85, 2, 2, 1712, 1713, 7, 71, 2, 2, 1713, 1714, 7, 85, 2, 2, 1714, 1715, 7, 85, 2, 2, 1715, 1716, 7, 75, 2, 2, 1716, 1717, 7, 81, 2, 2, 1717, 1718, 7, 80, 2, 2, 1718, 1719, 7, 97, 2, 2, 1719, 1720, 7, 87, 2, 2, 1720, 1721, 7, 85, 2, 2, 1721, 1722, 7, 71, 2, 2, 1722, 1723, 7, 84, 2, 2, 1723, 192, 3, 2, 2, 2, 1724, 1725, 7, 85, 2, 2, 1725, 1726, 7, 81, 2, 2, 1726, 1727, 7, 79, 2, 2, 1727, 1728, 7, 71, 2, 2, 1728, 194, 3, 2, 2, 2, 1729, 1730, 7, 85, 2, 2, 1730, 1731, 7, 91, 2, 2, 1731, 1732, 7, 79, 2, 2, 1732, 1733, 7, 79, 2, 2, 1733, 1734, 7, 71, 2, 2, 1734, 1735, 7, 86, 2, 2, 1735, 1736, 7, 84, 2, 2, 1736, 1737, 7, 75, 2, 2, 1737, 1738, 7, 69, 2, 2, 1738, 196, 3, 2, 2, 2, 1739, 1740, 7, 86, 2, 2, 1740, 1741, 7, 67, 2, 2, 1741, 1742, 7, 68, 2, 2, 1742, 1743, 7, 78, 2, 2, 1743, 1744, 7, 71, 2, 2, 1744, 198, 3, 2, 2, 2, 1745, 1746, 7, 86, 2, 2, 1746, 1747, 7, 74, 2, 2, 1747, 1748, 7, 71, 2, 2, 1748, 1749, 7, 80, 2, 2, 1749, 200, 3, 2, 2, 2, 1750, 1751, 7, 86, 2, 2, 1751, 1752, 7, 81, 2, 2, 1752, 202, 3, 2, 2, 2, 1753, 1754, 7, 86, 2, 2, 1754, 1755, 7, 84, 2, 2, 1755, 1756, 7, 67, 2, 2, 1756, 1757, 7, 75, 2, 2, 1757, 1758, 7, 78, 2, 2, 1758, 1759, 7, 75, 2, 2, 1759, 1760, 7, 80, 2, 2, 1760, 1761, 7, 73, 2, 2, 1761, 204, 3, 2, 2, 2, 1762, 1763, 7, 86, 2, 2, 1763, 1764, 7, 84, 2, 2, 1764, 1765, 7, 87, 2, 2, 1765, 1766, 7, 71, 2, 2, 1766, 206, 3, 2, 2, 2, 1767, 1768, 7, 87, 2, 2, 1768, 1769, 7, 80, 2, 2, 1769, 1770, 7, 75, 2, 2, 1770, 1771, 7, 81, 2, 2, 1771, 1772, 7, 80, 2, 2, 1772, 208, 3, 2, 2, 2, 1773, 1774, 7, 87, 2, 2, 1774, 1775, 7, 80, 2, 2, 1775, 1776, 7, 75, 2, 2, 1776, 1777, 7, 83, 2, 2, 1777, 1778, 7, 87, 2, 2, 1778, 1779, 7, 71, 2, 2, 1779, 210, 3, 2, 2, 2, 1780, 1781, 7, 87, 2, 2, 1781, 1782, 7, 85, 2, 2, 1782, 1783, 7, 71, 2, 2, 1783, 1784, 7, 84, 2, 2, 1784, 212, 3, 2, 2, 2, 1785, 1786, 7, 87, 2, 2, 1786, 1787, 7, 85, 2, 2, 1787, 1788, 7, 75, 2, 2, 1788, 1789, 7, 80, 2, 2, 1789, 1790, 7, 73, 2, 2, 1790, 214, 3, 2, 2, 2, 1791, 1792, 7, 88, 2, 2, 1792, 1793, 7, 67, 2, 2, 1793, 1794, 7, 84, 2, 2, 1794, 1795, 7, 75, 2, 2, 1795, 1796, 7, 67, 2, 2, 1796, 1797, 7, 70, 2, 2, 1797, 1798, 7, 75, 2, 2, 1798, 1799, 7, 69, 2, 2, 1799, 216, 3, 2, 2, 2, 1800, 1801, 7, 89, 2, 2, 1801, 1802, 7, 74, 2, 2, 1802, 1803, 7, 71, 2, 2, 1803, 1804, 7, 80, 2, 2, 1804, 218, 3, 2, 2, 2, 1805, 1806, 7, 89, 2, 2, 1806, 1807, 7, 74, 2, 2, 1807, 1808, 7, 71, 2, 2, 1808, 1809, 7, 84, 2, 2, 1809, 1810, 7, 71, 2, 2, 1810, 220, 3, 2, 2, 2, 1811, 1812, 7, 89, 2, 2, 1812, 1813, 7, 75, 2, 2, 1813, 1814, 7, 80, 2, 2, 1814, 1815, 7, 70, 2, 2, 1815, 1816, 7, 81, 2, 2, 1816, 1817, 7, 89, 2, 2, 1817, 222, 3, 2, 2, 2, 1818, 1819, 7, 89, 2, 2, 1819, 1820, 7, 75, 2, 2, 1820, 1821, 7, 86, 2, 2, 1821, 1822, 7, 74, 2, 2, 1822, 224, 3, 2, 2, 2, 1823, 1824, 7, 67, 2, 2, 1824, 1825, 7, 87, 2, 2, 1825, 1826, 7, 86, 2, 2, 1826, 1827, 7, 74, 2, 2, 1827, 1828, 7, 81, 2, 2, 1828, 1829, 7, 84, 2, 2, 1829, 1830, 7, 75, 2, 2, 1830, 1831, 7, 92, 2, 2, 1831, 1832, 7, 67, 2, 2, 1832, 1833, 7, 86, 2, 2, 1833, 1834, 7, 75, 2, 2, 1834, 1835, 7, 81, 2, 2, 1835, 1836, 7, 80, 2, 2, 1836, 226, 3, 2, 2, 2, 1837, 1838, 7, 68, 2, 2, 1838, 1839, 7, 75, 2, 2, 1839, 1840, 7, 80, 2, 2, 1840, 1841, 7, 67, 2, 2, 1841, 1842, 7, 84, 2, 2, 1842, 1843, 7, 91, 2, 2, 1843, 228, 3, 2, 2, 2, 1844, 1845, 7, 69, 2, 2, 1845, 1846, 7, 81, 2, 2, 1846, 1847, 7, 78, 2, 2, 1847, 1848, 7, 78, 2, 2, 1848, 1849, 7, 67, 2, 2, 1849, 1850, 7, 86, 2, 2, 1850, 1851, 7, 75, 2, 2, 1851, 1852, 7, 81, 2, 2, 1852, 1853, 7, 80, 2, 2, 1853, 230, 3, 2, 2, 2, 1854, 1855, 7, 69, 2, 2, 1855, 1856, 7, 81, 2, 2, 1856, 1857, 7, 80, 2, 2, 1857, 1858, 7, 69, 2, 2, 1858, 1859, 7, 87, 2, 2, 1859, 1860, 7, 84, 2, 2, 1860, 1861, 7, 84, 2, 2, 1861, 1862, 7, 71, 2, 2, 1862, 1863, 7, 80, 2, 2, 1863, 1864, 7, 86, 2, 2, 1864, 1865, 7, 78, 2, 2, 1865, 1866, 7, 91, 2, 2, 1866, 232, 3, 2, 2, 2, 1867, 1868, 7, 69, 2, 2, 1868, 1869, 7, 84, 2, 2, 1869, 1870, 7, 81, 2, 2, 1870, 1871, 7, 85, 2, 2, 1871, 1872, 7, 85, 2, 2, 1872, 234, 3, 2, 2, 2, 1873, 1874, 7, 69, 2, 2, 1874, 1875, 7, 87, 2, 2, 1875, 1876, 7, 84, 2, 2, 1876, 1877, 7, 84, 2, 2, 1877, 1878, 7, 71, 2, 2, 1878, 1879, 7, 80, 2, 2, 1879, 1880, 7, 86, 2, 2, 1880, 1881, 7, 97, 2, 2, 1881, 1882, 7, 85, 2, 2, 1882, 1883, 7, 69, 2, 2, 1883, 1884, 7, 74, 2, 2, 1884, 1885, 7, 71, 2, 2, 1885, 1886, 7, 79, 2, 2, 1886, 1887, 7, 67, 2, 2, 1887, 236, 3, 2, 2, 2, 1888, 1889, 7, 72, 2, 2, 1889, 1890, 7, 84, 2, 2, 1890, 1891, 7, 71, 2, 2, 1891, 1892, 7, 71, 2, 2, 1892, 1893, 7, 92, 2, 2, 1893, 1894, 7, 71, 2, 2, 1894, 238, 3, 2, 2, 2, 1895, 1896, 7, 72, 2, 2, 1896, 1897, 7, 87, 2, 2, 1897, 1898, 7, 78, 2, 2, 1898, 1899, 7, 78, 2, 2, 1899, 240, 3, 2, 2, 2, 1900, 1901, 7, 75, 2, 2, 1901, 1902, 7, 78, 2, 2, 1902, 1903, 7, 75, 2, 2, 1903, 1904, 7, 77, 2, 2, 1904, 1905, 7, 71, 2, 2, 1905, 242, 3, 2, 2, 2, 1906, 1907, 7, 75, 2, 2, 1907, 1908, 7, 80, 2, 2, 1908, 1909, 7, 80, 2, 2, 1909, 1910, 7, 71, 2, 2, 1910, 1911, 7, 84, 2, 2, 1911, 244, 3, 2, 2, 2, 1912, 1913, 7, 75, 2, 2, 1913, 1914, 7, 85, 2, 2, 1914, 246, 3, 2, 2, 2, 1915, 1916, 7, 75, 2, 2, 1916, 1917, 7, 85, 2, 2, 1917, 1918, 7, 80, 2, 2, 1918, 1919, 7, 87, 2, 2, 1919, 1920, 7, 78, 2, 2, 1920, 1921, 7, 78, 2, 2, 1921, 248, 3, 2, 2, 2, 1922, 1923, 7, 76, 2, 2, 1923, 1924, 7, 81, 2, 2, 1924, 1925, 7, 75, 2, 2, 1925, 1926, 7, 80, 2, 2, 1926, 250, 3, 2, 2, 2, 1927, 1928, 7, 78, 2, 2, 1928, 1929, 7, 71, 2, 2, 1929, 1930, 7, 72, 2, 2, 1930, 1931, 7, 86, 2, 2, 1931, 252, 3, 2, 2, 2, 1932, 1933, 7, 78, 2, 2, 1933, 1934, 7, 75, 2, 2, 1934, 1935, 7, 77, 2, 2, 1935, 1936, 7, 71, 2, 2, 1936, 254, 3, 2, 2, 2, 1937, 1938, 7, 80, 2, 2, 1938, 1939, 7, 67, 2, 2, 1939, 1940, 7, 86, 2, 2, 1940, 1941, 7, 87, 2, 2, 1941, 1942, 7, 84, 2, 2, 1942, 1943, 7, 67, 2, 2, 1943, 1944, 7, 78, 2, 2, 1944, 256, 3, 2, 2, 2, 1945, 1946, 7, 80, 2, 2, 1946, 1947, 7, 81, 2, 2, 1947, 1948, 7, 86, 2, 2, 1948, 1949, 7, 80, 2, 2, 1949, 1950, 7, 87, 2, 2, 1950, 1951, 7, 78, 2, 2, 1951, 1952, 7, 78, 2, 2, 1952, 258, 3, 2, 2, 2, 1953, 1954, 7, 81, 2, 2, 1954, 1955, 7, 87, 2, 2, 1955, 1956, 7, 86, 2, 2, 1956, 1957, 7, 71, 2, 2, 1957, 1958, 7, 84, 2, 2, 1958, 260, 3, 2, 2, 2, 1959, 1960, 7, 81, 2, 2, 1960, 1961, 7, 88, 2, 2, 1961, 1962, 7, 71, 2, 2, 1962, 1963, 7, 84, 2, 2, 1963, 262, 3, 2, 2, 2, 1964, 1965, 7, 81, 2, 2, 1965, 1966, 7, 88, 2, 2, 1966, 1967, 7, 71, 2, 2, 1967, 1968, 7, 84, 2, 2, 1968, 1969, 7, 78, 2, 2, 1969, 1970, 7, 67, 2, 2, 1970, 1971, 7, 82, 2, 2, 1971, 1972, 7, 85, 2, 2, 1972, 264, 3, 2, 2, 2, 1973, 1974, 7, 84, 2, 2, 1974, 1975, 7, 75, 2, 2, 1975, 1976, 7, 73, 2, 2, 1976, 1977, 7, 74, 2, 2, 1977, 1978, 7, 86, 2, 2, 1978, 266, 3, 2, 2, 2, 1979, 1980, 7, 85, 2, 2, 1980, 1981, 7, 75, 2, 2, 1981, 1982, 7, 79, 2, 2, 1982, 1983, 7, 75, 2, 2, 1983, 1984, 7, 78, 2, 2, 1984, 1985, 7, 67, 2, 2, 1985, 1986, 7, 84, 2, 2, 1986, 268, 3, 2, 2, 2, 1987, 1988, 7, 88, 2, 2, 1988, 1989, 7, 71, 2, 2, 1989, 1990, 7, 84, 2, 2, 1990, 1991, 7, 68, 2, 2, 1991, 1992, 7, 81, 2, 2, 1992, 1993, 7, 85, 2, 2, 1993, 1994, 7, 71, 2, 2, 1994, 270, 3, 2, 2, 2, 1995, 1996, 7, 67, 2, 2, 1996, 1997, 7, 68, 2, 2, 1997, 1998, 7, 81, 2, 2, 1998, 1999, 7, 84, 2, 2, 1999, 2000, 7, 86, 2, 2, 2000, 272, 3, 2, 2, 2, 2001, 2002, 7, 67, 2, 2, 2002, 2003, 7, 68, 2, 2, 2003, 2004, 7, 85, 2, 2, 2004, 2005, 7, 81, 2, 2, 2005, 2006, 7, 78, 2, 2, 2006, 2007, 7, 87, 2, 2, 2007, 2008, 7, 86, 2, 2, 2008, 2009, 7, 71, 2, 2, 2009, 274, 3, 2, 2, 2, 2010, 2011, 7, 67, 2, 2, 2011, 2012, 7, 69, 2, 2, 2012, 2013, 7, 69, 2, 2, 2013, 2014, 7, 71, 2, 2, 2014, 2015, 7, 85, 2, 2, 2015, 2016, 7, 85, 2, 2, 2016, 276, 3, 2, 2, 2, 2017, 2018, 7, 67, 2, 2, 2018, 2019, 7, 69, 2, 2, 2019, 2020, 7, 86, 2, 2, 2020, 2021, 7, 75, 2, 2, 2021, 2022, 7, 81, 2, 2, 2022, 2023, 7, 80, 2, 2, 2023, 278, 3, 2, 2, 2, 2024, 2025, 7, 67, 2, 2, 2025, 2026, 7, 70, 2, 2, 2026, 2027, 7, 70, 2, 2, 2027, 280, 3, 2, 2, 2, 2028, 2029, 7, 67, 2, 2, 2029, 2030, 7, 70, 2, 2, 2030, 2031, 7, 79, 2, 2, 2031, 2032, 7, 75, 2, 2, 2032, 2033, 7, 80, 2, 2, 2033, 282, 3, 2, 2, 2, 2034, 2035, 7, 67, 2, 2, 2035, 2036, 7, 72, 2, 2, 2036, 2037, 7, 86, 2, 2, 2037, 2038, 7, 71, 2, 2, 2038, 2039, 7, 84, 2, 2, 2039, 284, 3, 2, 2, 2, 2040, 2041, 7, 67, 2, 2, 2041, 2042, 7, 73, 2, 2, 2042, 2043, 7, 73, 2, 2, 2043, 2044, 7, 84, 2, 2, 2044, 2045, 7, 71, 2, 2, 2045, 2046, 7, 73, 2, 2, 2046, 2047, 7, 67, 2, 2, 2047, 2048, 7, 86, 2, 2, 2048, 2049, 7, 71, 2, 2, 2049, 286, 3, 2, 2, 2, 2050, 2051, 7, 67, 2, 2, 2051, 2052, 7, 78, 2, 2, 2052, 2053, 7, 85, 2, 2, 2053, 2054, 7, 81, 2, 2, 2054, 288, 3, 2, 2, 2, 2055, 2056, 7, 67, 2, 2, 2056, 2057, 7, 78, 2, 2, 2057, 2058, 7, 86, 2, 2, 2058, 2059, 7, 71, 2, 2, 2059, 2060, 7, 84, 2, 2, 2060, 290, 3, 2, 2, 2, 2061, 2062, 7, 67, 2, 2, 2062, 2063, 7, 78, 2, 2, 2063, 2064, 7, 89, 2, 2, 2064, 2065, 7, 67, 2, 2, 2065, 2066, 7, 91, 2, 2, 2066, 2067, 7, 85, 2, 2, 2067, 292, 3, 2, 2, 2, 2068, 2069, 7, 67, 2, 2, 2069, 2070, 7, 85, 2, 2, 2070, 2071, 7, 85, 2, 2, 2071, 2072, 7, 71, 2, 2, 2072, 2073, 7, 84, 2, 2, 2073, 2074, 7, 86, 2, 2, 2074, 2075, 7, 75, 2, 2, 2075, 2076, 7, 81, 2, 2, 2076, 2077, 7, 80, 2, 2, 2077, 294, 3, 2, 2, 2, 2078, 2079, 7, 67, 2, 2, 2079, 2080, 7, 85, 2, 2, 2080, 2081, 7, 85, 2, 2, 2081, 2082, 7, 75, 2, 2, 2082, 2083, 7, 73, 2, 2, 2083, 2084, 7, 80, 2, 2, 2084, 2085, 7, 79, 2, 2, 2085, 2086, 7, 71, 2, 2, 2086, 2087, 7, 80, 2, 2, 2087, 2088, 7, 86, 2, 2, 2088, 296, 3, 2, 2, 2, 2089, 2090, 7, 67, 2, 2, 2090, 2091, 7, 86, 2, 2, 2091, 298, 3, 2, 2, 2, 2092, 2093, 7, 67, 2, 2, 2093, 2094, 7, 86, 2, 2, 2094, 2095, 7, 86, 2, 2, 2095, 2096, 7, 84, 2, 2, 2096, 2097, 7, 75, 2, 2, 2097, 2098, 7, 68, 2, 2, 2098, 2099, 7, 87, 2, 2, 2099, 2100, 7, 86, 2, 2, 2100, 2101, 7, 71, 2, 2, 2101, 300, 3, 2, 2, 2, 2102, 2103, 7, 68, 2, 2, 2103, 2104, 7, 67, 2, 2, 2104, 2105, 7, 69, 2, 2, 2105, 2106, 7, 77, 2, 2, 2106, 2107, 7, 89, 2, 2, 2107, 2108, 7, 67, 2, 2, 2108, 2109, 7, 84, 2, 2, 2109, 2110, 7, 70, 2, 2, 2110, 302, 3, 2, 2, 2, 2111, 2112, 7, 68, 2, 2, 2112, 2113, 7, 71, 2, 2, 2113, 2114, 7, 72, 2, 2, 2114, 2115, 7, 81, 2, 2, 2115, 2116, 7, 84, 2, 2, 2116, 2117, 7, 71, 2, 2, 2117, 304, 3, 2, 2, 2, 2118, 2119, 7, 68, 2, 2, 2119, 2120, 7, 71, 2, 2, 2120, 2121, 7, 73, 2, 2, 2121, 2122, 7, 75, 2, 2, 2122, 2123, 7, 80, 2, 2, 2123, 306, 3, 2, 2, 2, 2124, 2125, 7, 68, 2, 2, 2125, 2126, 7, 91, 2, 2, 2126, 308, 3, 2, 2, 2, 2127, 2128, 7, 69, 2, 2, 2128, 2129, 7, 67, 2, 2, 2129, 2130, 7, 69, 2, 2, 2130, 2131, 7, 74, 2, 2, 2131, 2132, 7, 71, 2, 2, 2132, 310, 3, 2, 2, 2, 2133, 2134, 7, 69, 2, 2, 2134, 2135, 7, 67, 2, 2, 2135, 2136, 7, 78, 2, 2, 2136, 2137, 7, 78, 2, 2, 2137, 2138, 7, 71, 2, 2, 2138, 2139, 7, 70, 2, 2, 2139, 312, 3, 2, 2, 2, 2140, 2141, 7, 69, 2, 2, 2141, 2142, 7, 67, 2, 2, 2142, 2143, 7, 85, 2, 2, 2143, 2144, 7, 69, 2, 2, 2144, 2145, 7, 67, 2, 2, 2145, 2146, 7, 70, 2, 2, 2146, 2147, 7, 71, 2, 2, 2147, 314, 3, 2, 2, 2, 2148, 2149, 7, 69, 2, 2, 2149, 2150, 7, 67, 2, 2, 2150, 2151, 7, 85, 2, 2, 2151, 2152, 7, 69, 2, 2, 2152, 2153, 7, 67, 2, 2, 2153, 2154, 7, 70, 2, 2, 2154, 2155, 7, 71, 2, 2, 2155, 2156, 7, 70, 2, 2, 2156, 316, 3, 2, 2, 2, 2157, 2158, 7, 69, 2, 2, 2158, 2159, 7, 67, 2, 2, 2159, 2160, 7, 86, 2, 2, 2160, 2161, 7, 67, 2, 2, 2161, 2162, 7, 78, 2, 2, 2162, 2163, 7, 81, 2, 2, 2163, 2164, 7, 73, 2, 2, 2164, 318, 3, 2, 2, 2, 2165, 2166, 7, 69, 2, 2, 2166, 2167, 7, 74, 2, 2, 2167, 2168, 7, 67, 2, 2, 2168, 2169, 7, 75, 2, 2, 2169, 2170, 7, 80, 2, 2, 2170, 320, 3, 2, 2, 2, 2171, 2172, 7, 69, 2, 2, 2172, 2173, 7, 74, 2, 2, 2173, 2174, 7, 67, 2, 2, 2174, 2175, 7, 84, 2, 2, 2175, 2176, 7, 67, 2, 2, 2176, 2177, 7, 69, 2, 2, 2177, 2178, 7, 86, 2, 2, 2178, 2179, 7, 71, 2, 2, 2179, 2180, 7, 84, 2, 2, 2180, 2181, 7, 75, 2, 2, 2181, 2182, 7, 85, 2, 2, 2182, 2183, 7, 86, 2, 2, 2183, 2184, 7, 75, 2, 2, 2184, 2185, 7, 69, 2, 2, 2185, 2186, 7, 85, 2, 2, 2186, 322, 3, 2, 2, 2, 2187, 2188, 7, 69, 2, 2, 2188, 2189, 7, 74, 2, 2, 2189, 2190, 7, 71, 2, 2, 2190, 2191, 7, 69, 2, 2, 2191, 2192, 7, 77, 2, 2, 2192, 2193, 7, 82, 2, 2, 2193, 2194, 7, 81, 2, 2, 2194, 2195, 7, 75, 2, 2, 2195, 2196, 7, 80, 2, 2, 2196, 2197, 7, 86, 2, 2, 2197, 324, 3, 2, 2, 2, 2198, 2199, 7, 69, 2, 2, 2199, 2200, 7, 78, 2, 2, 2200, 2201, 7, 67, 2, 2, 2201, 2202, 7, 85, 2, 2, 2202, 2203, 7, 85, 2, 2, 2203, 326, 3, 2, 2, 2, 2204, 2205, 7, 69, 2, 2, 2205, 2206, 7, 78, 2, 2, 2206, 2207, 7, 81, 2, 2, 2207, 2208, 7, 85, 2, 2, 2208, 2209, 7, 71, 2, 2, 2209, 328, 3, 2, 2, 2, 2210, 2211, 7, 69, 2, 2, 2211, 2212, 7, 78, 2, 2, 2212, 2213, 7, 87, 2, 2, 2213, 2214, 7, 85, 2, 2, 2214, 2215, 7, 86, 2, 2, 2215, 2216, 7, 71, 2, 2, 2216, 2217, 7, 84, 2, 2, 2217, 330, 3, 2, 2, 2, 2218, 2219, 7, 69, 2, 2, 2219, 2220, 7, 81, 2, 2, 2220, 2221, 7, 79, 2, 2, 2221, 2222, 7, 79, 2, 2, 2222, 2223, 7, 71, 2, 2, 2223, 2224, 7, 80, 2, 2, 2224, 2225, 7, 86, 2, 2, 2225, 332, 3, 2, 2, 2, 2226, 2227, 7, 69, 2, 2, 2227, 2228, 7, 81, 2, 2, 2228, 2229, 7, 79, 2, 2, 2229, 2230, 7, 79, 2, 2, 2230, 2231, 7, 71, 2, 2, 2231, 2232, 7, 80, 2, 2, 2232, 2233, 7, 86, 2, 2, 2233, 2234, 7, 85, 2, 2, 2234, 334, 3, 2, 2, 2, 2235, 2236, 7, 69, 2, 2, 2236, 2237, 7, 81, 2, 2, 2237, 2238, 7, 79, 2, 2, 2238, 2239, 7, 79, 2, 2, 2239, 2240, 7, 75, 2, 2, 2240, 2241, 7, 86, 2, 2, 2241, 336, 3, 2, 2, 2, 2242, 2243, 7, 69, 2, 2, 2243, 2244, 7, 81, 2, 2, 2244, 2245, 7, 79, 2, 2, 2245, 2246, 7, 79, 2, 2, 2246, 2247, 7, 75, 2, 2, 2247, 2248, 7, 86, 2, 2, 2248, 2249, 7, 86, 2, 2, 2249, 2250, 7, 71, 2, 2, 2250, 2251, 7, 70, 2, 2, 2251, 338, 3, 2, 2, 2, 2252, 2253, 7, 69, 2, 2, 2253, 2254, 7, 81, 2, 2, 2254, 2255, 7, 80, 2, 2, 2255, 2256, 7, 72, 2, 2, 2256, 2257, 7, 75, 2, 2, 2257, 2258, 7, 73, 2, 2, 2258, 2259, 7, 87, 2, 2, 2259, 2260, 7, 84, 2, 2, 2260, 2261, 7, 67, 2, 2, 2261, 2262, 7, 86, 2, 2, 2262, 2263, 7, 75, 2, 2, 2263, 2264, 7, 81, 2, 2, 2264, 2265, 7, 80, 2, 2, 2265, 340, 3, 2, 2, 2, 2266, 2267, 7, 69, 2, 2, 2267, 2268, 7, 81, 2, 2, 2268, 2269, 7, 80, 2, 2, 2269, 2270, 7, 80, 2, 2, 2270, 2271, 7, 71, 2, 2, 2271, 2272, 7, 69, 2, 2, 2272, 2273, 7, 86, 2, 2, 2273, 2274, 7, 75, 2, 2, 2274, 2275, 7, 81, 2, 2, 2275, 2276, 7, 80, 2, 2, 2276, 342, 3, 2, 2, 2, 2277, 2278, 7, 69, 2, 2, 2278, 2279, 7, 81, 2, 2, 2279, 2280, 7, 80, 2, 2, 2280, 2281, 7, 85, 2, 2, 2281, 2282, 7, 86, 2, 2, 2282, 2283, 7, 84, 2, 2, 2283, 2284, 7, 67, 2, 2, 2284, 2285, 7, 75, 2, 2, 2285, 2286, 7, 80, 2, 2, 2286, 2287, 7, 86, 2, 2, 2287, 2288, 7, 85, 2, 2, 2288, 344, 3, 2, 2, 2, 2289, 2290, 7, 69, 2, 2, 2290, 2291, 7, 81, 2, 2, 2291, 2292, 7, 80, 2, 2, 2292, 2293, 7, 86, 2, 2, 2293, 2294, 7, 71, 2, 2, 2294, 2295, 7, 80, 2, 2, 2295, 2296, 7, 86, 2, 2, 2296, 346, 3, 2, 2, 2, 2297, 2298, 7, 69, 2, 2, 2298, 2299, 7, 81, 2, 2, 2299, 2300, 7, 80, 2, 2, 2300, 2301, 7, 86, 2, 2, 2301, 2302, 7, 75, 2, 2, 2302, 2303, 7, 80, 2, 2, 2303, 2304, 7, 87, 2, 2, 2304, 2305, 7, 71, 2, 2, 2305, 348, 3, 2, 2, 2, 2306, 2307, 7, 69, 2, 2, 2307, 2308, 7, 81, 2, 2, 2308, 2309, 7, 80, 2, 2, 2309, 2310, 7, 88, 2, 2, 2310, 2311, 7, 71, 2, 2, 2311, 2312, 7, 84, 2, 2, 2312, 2313, 7, 85, 2, 2, 2313, 2314, 7, 75, 2, 2, 2314, 2315, 7, 81, 2, 2, 2315, 2316, 7, 80, 2, 2, 2316, 350, 3, 2, 2, 2, 2317, 2318, 7, 69, 2, 2, 2318, 2319, 7, 81, 2, 2, 2319, 2320, 7, 82, 2, 2, 2320, 2321, 7, 91, 2, 2, 2321, 352, 3, 2, 2, 2, 2322, 2323, 7, 69, 2, 2, 2323, 2324, 7, 81, 2, 2, 2324, 2325, 7, 85, 2, 2, 2325, 2326, 7, 86, 2, 2, 2326, 354, 3, 2, 2, 2, 2327, 2328, 7, 69, 2, 2, 2328, 2329, 7, 85, 2, 2, 2329, 2330, 7, 88, 2, 2, 2330, 356, 3, 2, 2, 2, 2331, 2332, 7, 69, 2, 2, 2332, 2333, 7, 87, 2, 2, 2333, 2334, 7, 84, 2, 2, 2334, 2335, 7, 85, 2, 2, 2335, 2336, 7, 81, 2, 2, 2336, 2337, 7, 84, 2, 2, 2337, 358, 3, 2, 2, 2, 2338, 2339, 7, 69, 2, 2, 2339, 2340, 7, 91, 2, 2, 2340, 2341, 7, 69, 2, 2, 2341, 2342, 7, 78, 2, 2, 2342, 2343, 7, 71, 2, 2, 2343, 360, 3, 2, 2, 2, 2344, 2345, 7, 70, 2, 2, 2345, 2346, 7, 67, 2, 2, 2346, 2347, 7, 86, 2, 2, 2347, 2348, 7, 67, 2, 2, 2348, 362, 3, 2, 2, 2, 2349, 2350, 7, 70, 2, 2, 2350, 2351, 7, 67, 2, 2, 2351, 2352, 7, 86, 2, 2, 2352, 2353, 7, 67, 2, 2, 2353, 2354, 7, 68, 2, 2, 2354, 2355, 7, 67, 2, 2, 2355, 2356, 7, 85, 2, 2, 2356, 2357, 7, 71, 2, 2, 2357, 364, 3, 2, 2, 2, 2358, 2359, 7, 70, 2, 2, 2359, 2360, 7, 67, 2, 2, 2360, 2361, 7, 91, 2, 2, 2361, 366, 3, 2, 2, 2, 2362, 2363, 7, 70, 2, 2, 2363, 2364, 7, 71, 2, 2, 2364, 2365, 7, 67, 2, 2, 2365, 2366, 7, 78, 2, 2, 2366, 2367, 7, 78, 2, 2, 2367, 2368, 7, 81, 2, 2, 2368, 2369, 7, 69, 2, 2, 2369, 2370, 7, 67, 2, 2, 2370, 2371, 7, 86, 2, 2, 2371, 2372, 7, 71, 2, 2, 2372, 368, 3, 2, 2, 2, 2373, 2374, 7, 70, 2, 2, 2374, 2375, 7, 71, 2, 2, 2375, 2376, 7, 69, 2, 2, 2376, 2377, 7, 78, 2, 2, 2377, 2378, 7, 67, 2, 2, 2378, 2379, 7, 84, 2, 2, 2379, 2380, 7, 71, 2, 2, 2380, 370, 3, 2, 2, 2, 2381, 2382, 7, 70, 2, 2, 2382, 2383, 7, 71, 2, 2, 2383, 2384, 7, 72, 2, 2, 2384, 2385, 7, 67, 2, 2, 2385, 2386, 7, 87, 2, 2, 2386, 2387, 7, 78, 2, 2, 2387, 2388, 7, 86, 2, 2, 2388, 2389, 7, 85, 2, 2, 2389, 372, 3, 2, 2, 2, 2390, 2391, 7, 70, 2, 2, 2391, 2392, 7, 71, 2, 2, 2392, 2393, 7, 72, 2, 2, 2393, 2394, 7, 71, 2, 2, 2394, 2395, 7, 84, 2, 2, 2395, 2396, 7, 84, 2, 2, 2396, 2397, 7, 71, 2, 2, 2397, 2398, 7, 70, 2, 2, 2398, 374, 3, 2, 2, 2, 2399, 2400, 7, 70, 2, 2, 2400, 2401, 7, 71, 2, 2, 2401, 2402, 7, 72, 2, 2, 2402, 2403, 7, 75, 2, 2, 2403, 2404, 7, 80, 2, 2, 2404, 2405, 7, 71, 2, 2, 2405, 2406, 7, 84, 2, 2, 2406, 376, 3, 2, 2, 2, 2407, 2408, 7, 70, 2, 2, 2408, 2409, 7, 71, 2, 2, 2409, 2410, 7, 78, 2, 2, 2410, 2411, 7, 71, 2, 2, 2411, 2412, 7, 86, 2, 2, 2412, 2413, 7, 71, 2, 2, 2413, 378, 3, 2, 2, 2, 2414, 2415, 7, 70, 2, 2, 2415, 2416, 7, 71, 2, 2, 2416, 2417, 7, 78, 2, 2, 2417, 2418, 7, 75, 2, 2, 2418, 2419, 7, 79, 2, 2, 2419, 2420, 7, 75, 2, 2, 2420, 2421, 7, 86, 2, 2, 2421, 2422, 7, 71, 2, 2, 2422, 2423, 7, 84, 2, 2, 2423, 380, 3, 2, 2, 2, 2424, 2425, 7, 70, 2, 2, 2425, 2426, 7, 71, 2, 2, 2426, 2427, 7, 78, 2, 2, 2427, 2428, 7, 75, 2, 2, 2428, 2429, 7, 79, 2, 2, 2429, 2430, 7, 75, 2, 2, 2430, 2431, 7, 86, 2, 2, 2431, 2432, 7, 71, 2, 2, 2432, 2433, 7, 84, 2, 2, 2433, 2434, 7, 85, 2, 2, 2434, 382, 3, 2, 2, 2, 2435, 2436, 7, 70, 2, 2, 2436, 2437, 7, 75, 2, 2, 2437, 2438, 7, 69, 2, 2, 2438, 2439, 7, 86, 2, 2, 2439, 2440, 7, 75, 2, 2, 2440, 2441, 7, 81, 2, 2, 2441, 2442, 7, 80, 2, 2, 2442, 2443, 7, 67, 2, 2, 2443, 2444, 7, 84, 2, 2, 2444, 2445, 7, 91, 2, 2, 2445, 384, 3, 2, 2, 2, 2446, 2447, 7, 70, 2, 2, 2447, 2448, 7, 75, 2, 2, 2448, 2449, 7, 85, 2, 2, 2449, 2450, 7, 67, 2, 2, 2450, 2451, 7, 68, 2, 2, 2451, 2452, 7, 78, 2, 2, 2452, 2453, 7, 71, 2, 2, 2453, 386, 3, 2, 2, 2, 2454, 2455, 7, 70, 2, 2, 2455, 2456, 7, 75, 2, 2, 2456, 2457, 7, 85, 2, 2, 2457, 2458, 7, 69, 2, 2, 2458, 2459, 7, 67, 2, 2, 2459, 2460, 7, 84, 2, 2, 2460, 2461, 7, 70, 2, 2, 2461, 388, 3, 2, 2, 2, 2462, 2463, 7, 70, 2, 2, 2463, 2464, 7, 81, 2, 2, 2464, 2465, 7, 69, 2, 2, 2465, 2466, 7, 87, 2, 2, 2466, 2467, 7, 79, 2, 2, 2467, 2468, 7, 71, 2, 2, 2468, 2469, 7, 80, 2, 2, 2469, 2470, 7, 86, 2, 2, 2470, 390, 3, 2, 2, 2, 2471, 2472, 7, 70, 2, 2, 2472, 2473, 7, 81, 2, 2, 2473, 2474, 7, 79, 2, 2, 2474, 2475, 7, 67, 2, 2, 2475, 2476, 7, 75, 2, 2, 2476, 2477, 7, 80, 2, 2, 2477, 392, 3, 2, 2, 2, 2478, 2479, 7, 70, 2, 2, 2479, 2480, 7, 81, 2, 2, 2480, 2481, 7, 87, 2, 2, 2481, 2482, 7, 68, 2, 2, 2482, 2483, 7, 78, 2, 2, 2483, 2484, 7, 71, 2, 2, 2484, 394, 3, 2, 2, 2, 2485, 2486, 7, 70, 2, 2, 2486, 2487, 7, 84, 2, 2, 2487, 2488, 7, 81, 2, 2, 2488, 2489, 7, 82, 2, 2, 2489, 396, 3, 2, 2, 2, 2490, 2491, 7, 71, 2, 2, 2491, 2492, 7, 67, 2, 2, 2492, 2493, 7, 69, 2, 2, 2493, 2494, 7, 74, 2, 2, 2494, 398, 3, 2, 2, 2, 2495, 2496, 7, 71, 2, 2, 2496, 2497, 7, 80, 2, 2, 2497, 2498, 7, 67, 2, 2, 2498, 2499, 7, 68, 2, 2, 2499, 2500, 7, 78, 2, 2, 2500, 2501, 7, 71, 2, 2, 2501, 400, 3, 2, 2, 2, 2502, 2503, 7, 71, 2, 2, 2503, 2504, 7, 80, 2, 2, 2504, 2505, 7, 69, 2, 2, 2505, 2506, 7, 81, 2, 2, 2506, 2507, 7, 70, 2, 2, 2507, 2508, 7, 75, 2, 2, 2508, 2509, 7, 80, 2, 2, 2509, 2510, 7, 73, 2, 2, 2510, 402, 3, 2, 2, 2, 2511, 2512, 7, 71, 2, 2, 2512, 2513, 7, 80, 2, 2, 2513, 2514, 7, 69, 2, 2, 2514, 2515, 7, 84, 2, 2, 2515, 2516, 7, 91, 2, 2, 2516, 2517, 7, 82, 2, 2, 2517, 2518, 7, 86, 2, 2, 2518, 2519, 7, 71, 2, 2, 2519, 2520, 7, 70, 2, 2, 2520, 404, 3, 2, 2, 2, 2521, 2522, 7, 71, 2, 2, 2522, 2523, 7, 80, 2, 2, 2523, 2524, 7, 87, 2, 2, 2524, 2525, 7, 79, 2, 2, 2525, 406, 3, 2, 2, 2, 2526, 2527, 7, 71, 2, 2, 2527, 2528, 7, 85, 2, 2, 2528, 2529, 7, 69, 2, 2, 2529, 2530, 7, 67, 2, 2, 2530, 2531, 7, 82, 2, 2, 2531, 2532, 7, 71, 2, 2, 2532, 408, 3, 2, 2, 2, 2533, 2534, 7, 71, 2, 2, 2534, 2535, 7, 88, 2, 2, 2535, 2536, 7, 71, 2, 2, 2536, 2537, 7, 80, 2, 2, 2537, 2538, 7, 86, 2, 2, 2538, 410, 3, 2, 2, 2, 2539, 2540, 7, 71, 2, 2, 2540, 2541, 7, 90, 2, 2, 2541, 2542, 7, 69, 2, 2, 2542, 2543, 7, 78, 2, 2, 2543, 2544, 7, 87, 2, 2, 2544, 2545, 7, 70, 2, 2, 2545, 2546, 7, 71, 2, 2, 2546, 412, 3, 2, 2, 2, 2547, 2548, 7, 71, 2, 2, 2548, 2549, 7, 90, 2, 2, 2549, 2550, 7, 69, 2, 2, 2550, 2551, 7, 78, 2, 2, 2551, 2552, 7, 87, 2, 2, 2552, 2553, 7, 70, 2, 2, 2553, 2554, 7, 75, 2, 2, 2554, 2555, 7, 80, 2, 2, 2555, 2556, 7, 73, 2, 2, 2556, 414, 3, 2, 2, 2, 2557, 2558, 7, 71, 2, 2, 2558, 2559, 7, 90, 2, 2, 2559, 2560, 7, 69, 2, 2, 2560, 2561, 7, 78, 2, 2, 2561, 2562, 7, 87, 2, 2, 2562, 2563, 7, 85, 2, 2, 2563, 2564, 7, 75, 2, 2, 2564, 2565, 7, 88, 2, 2, 2565, 2566, 7, 71, 2, 2, 2566, 416, 3, 2, 2, 2, 2567, 2568, 7, 71, 2, 2, 2568, 2569, 7, 90, 2, 2, 2569, 2570, 7, 71, 2, 2, 2570, 2571, 7, 69, 2, 2, 2571, 2572, 7, 87, 2, 2, 2572, 2573, 7, 86, 2, 2, 2573, 2574, 7, 71, 2, 2, 2574, 418, 3, 2, 2, 2, 2575, 2576, 7, 71, 2, 2, 2576, 2577, 7, 90, 2, 2, 2577, 2578, 7, 82, 2, 2, 2578, 2579, 7, 78, 2, 2, 2579, 2580, 7, 67, 2, 2, 2580, 2581, 7, 75, 2, 2, 2581, 2582, 7, 80, 2, 2, 2582, 420, 3, 2, 2, 2, 2583, 2584, 7, 71, 2, 2, 2584, 2585, 7, 90, 2, 2, 2585, 2586, 7, 86, 2, 2, 2586, 2587, 7, 71, 2, 2, 2587, 2588, 7, 80, 2, 2, 2588, 2589, 7, 85, 2, 2, 2589, 2590, 7, 75, 2, 2, 2590, 2591, 7, 81, 2, 2, 2591, 2592, 7, 80, 2, 2, 2592, 422, 3, 2, 2, 2, 2593, 2594, 7, 71, 2, 2, 2594, 2595, 7, 90, 2, 2, 2595, 2596, 7, 86, 2, 2, 2596, 2597, 7, 71, 2, 2, 2597, 2598, 7, 84, 2, 2, 2598, 2599, 7, 80, 2, 2, 2599, 2600, 7, 67, 2, 2, 2600, 2601, 7, 78, 2, 2, 2601, 424, 3, 2, 2, 2, 2602, 2603, 7, 72, 2, 2, 2603, 2604, 7, 67, 2, 2, 2604, 2605, 7, 79, 2, 2, 2605, 2606, 7, 75, 2, 2, 2606, 2607, 7, 78, 2, 2, 2607, 2608, 7, 91, 2, 2, 2608, 426, 3, 2, 2, 2, 2609, 2610, 7, 72, 2, 2, 2610, 2611, 7, 75, 2, 2, 2611, 2612, 7, 84, 2, 2, 2612, 2613, 7, 85, 2, 2, 2613, 2614, 7, 86, 2, 2, 2614, 428, 3, 2, 2, 2, 2615, 2616, 7, 72, 2, 2, 2616, 2617, 7, 81, 2, 2, 2617, 2618, 7, 78, 2, 2, 2618, 2619, 7, 78, 2, 2, 2619, 2620, 7, 81, 2, 2, 2620, 2621, 7, 89, 2, 2, 2621, 2622, 7, 75, 2, 2, 2622, 2623, 7, 80, 2, 2, 2623, 2624, 7, 73, 2, 2, 2624, 430, 3, 2, 2, 2, 2625, 2626, 7, 72, 2, 2, 2626, 2627, 7, 81, 2, 2, 2627, 2628, 7, 84, 2, 2, 2628, 2629, 7, 69, 2, 2, 2629, 2630, 7, 71, 2, 2, 2630, 432, 3, 2, 2, 2, 2631, 2632, 7, 72, 2, 2, 2632, 2633, 7, 81, 2, 2, 2633, 2634, 7, 84, 2, 2, 2634, 2635, 7, 89, 2, 2, 2635, 2636, 7, 67, 2, 2, 2636, 2637, 7, 84, 2, 2, 2637, 2638, 7, 70, 2, 2, 2638, 434, 3, 2, 2, 2, 2639, 2640, 7, 72, 2, 2, 2640, 2641, 7, 87, 2, 2, 2641, 2642, 7, 80, 2, 2, 2642, 2643, 7, 69, 2, 2, 2643, 2644, 7, 86, 2, 2, 2644, 2645, 7, 75, 2, 2, 2645, 2646, 7, 81, 2, 2, 2646, 2647, 7, 80, 2, 2, 2647, 436, 3, 2, 2, 2, 2648, 2649, 7, 72, 2, 2, 2649, 2650, 7, 87, 2, 2, 2650, 2651, 7, 80, 2, 2, 2651, 2652, 7, 69, 2, 2, 2652, 2653, 7, 86, 2, 2, 2653, 2654, 7, 75, 2, 2, 2654, 2655, 7, 81, 2, 2, 2655, 2656, 7, 80, 2, 2, 2656, 2657, 7, 85, 2, 2, 2657, 438, 3, 2, 2, 2, 2658, 2659, 7, 73, 2, 2, 2659, 2660, 7, 78, 2, 2, 2660, 2661, 7, 81, 2, 2, 2661, 2662, 7, 68, 2, 2, 2662, 2663, 7, 67, 2, 2, 2663, 2664, 7, 78, 2, 2, 2664, 440, 3, 2, 2, 2, 2665, 2666, 7, 73, 2, 2, 2666, 2667, 7, 84, 2, 2, 2667, 2668, 7, 67, 2, 2, 2668, 2669, 7, 80, 2, 2, 2669, 2670, 7, 86, 2, 2, 2670, 2671, 7, 71, 2, 2, 2671, 2672, 7, 70, 2, 2, 2672, 442, 3, 2, 2, 2, 2673, 2674, 7, 74, 2, 2, 2674, 2675, 7, 67, 2, 2, 2675, 2676, 7, 80, 2, 2, 2676, 2677, 7, 70, 2, 2, 2677, 2678, 7, 78, 2, 2, 2678, 2679, 7, 71, 2, 2, 2679, 2680, 7, 84, 2, 2, 2680, 444, 3, 2, 2, 2, 2681, 2682, 7, 74, 2, 2, 2682, 2683, 7, 71, 2, 2, 2683, 2684, 7, 67, 2, 2, 2684, 2685, 7, 70, 2, 2, 2685, 2686, 7, 71, 2, 2, 2686, 2687, 7, 84, 2, 2, 2687, 446, 3, 2, 2, 2, 2688, 2689, 7, 74, 2, 2, 2689, 2690, 7, 81, 2, 2, 2690, 2691, 7, 78, 2, 2, 2691, 2692, 7, 70, 2, 2, 2692, 448, 3, 2, 2, 2, 2693, 2694, 7, 74, 2, 2, 2694, 2695, 7, 81, 2, 2, 2695, 2696, 7, 87, 2, 2, 2696, 2697, 7, 84, 2, 2, 2697, 450, 3, 2, 2, 2, 2698, 2699, 7, 75, 2, 2, 2699, 2700, 7, 70, 2, 2, 2700, 2701, 7, 71, 2, 2, 2701, 2702, 7, 80, 2, 2, 2702, 2703, 7, 86, 2, 2, 2703, 2704, 7, 75, 2, 2, 2704, 2705, 7, 86, 2, 2, 2705, 2706, 7, 91, 2, 2, 2706, 452, 3, 2, 2, 2, 2707, 2708, 7, 75, 2, 2, 2708, 2709, 7, 72, 2, 2, 2709, 454, 3, 2, 2, 2, 2710, 2711, 7, 75, 2, 2, 2711, 2712, 7, 79, 2, 2, 2712, 2713, 7, 79, 2, 2, 2713, 2714, 7, 71, 2, 2, 2714, 2715, 7, 70, 2, 2, 2715, 2716, 7, 75, 2, 2, 2716, 2717, 7, 67, 2, 2, 2717, 2718, 7, 86, 2, 2, 2718, 2719, 7, 71, 2, 2, 2719, 456, 3, 2, 2, 2, 2720, 2721, 7, 75, 2, 2, 2721, 2722, 7, 79, 2, 2, 2722, 2723, 7, 79, 2, 2, 2723, 2724, 7, 87, 2, 2, 2724, 2725, 7, 86, 2, 2, 2725, 2726, 7, 67, 2, 2, 2726, 2727, 7, 68, 2, 2, 2727, 2728, 7, 78, 2, 2, 2728, 2729, 7, 71, 2, 2, 2729, 458, 3, 2, 2, 2, 2730, 2731, 7, 75, 2, 2, 2731, 2732, 7, 79, 2, 2, 2732, 2733, 7, 82, 2, 2, 2733, 2734, 7, 78, 2, 2, 2734, 2735, 7, 75, 2, 2, 2735, 2736, 7, 69, 2, 2, 2736, 2737, 7, 75, 2, 2, 2737, 2738, 7, 86, 2, 2, 2738, 460, 3, 2, 2, 2, 2739, 2740, 7, 75, 2, 2, 2740, 2741, 7, 80, 2, 2, 2741, 2742, 7, 69, 2, 2, 2742, 2743, 7, 78, 2, 2, 2743, 2744, 7, 87, 2, 2, 2744, 2745, 7, 70, 2, 2, 2745, 2746, 7, 75, 2, 2, 2746, 2747, 7, 80, 2, 2, 2747, 2748, 7, 73, 2, 2, 2748, 462, 3, 2, 2, 2, 2749, 2750, 7, 75, 2, 2, 2750, 2751, 7, 80, 2, 2, 2751, 2752, 7, 69, 2, 2, 2752, 2753, 7, 84, 2, 2, 2753, 2754, 7, 71, 2, 2, 2754, 2755, 7, 79, 2, 2, 2755, 2756, 7, 71, 2, 2, 2756, 2757, 7, 80, 2, 2, 2757, 2758, 7, 86, 2, 2, 2758, 464, 3, 2, 2, 2, 2759, 2760, 7, 75, 2, 2, 2760, 2761, 7, 80, 2, 2, 2761, 2762, 7, 70, 2, 2, 2762, 2763, 7, 71, 2, 2, 2763, 2764, 7, 90, 2, 2, 2764, 466, 3, 2, 2, 2, 2765, 2766, 7, 75, 2, 2, 2766, 2767, 7, 80, 2, 2, 2767, 2768, 7, 70, 2, 2, 2768, 2769, 7, 71, 2, 2, 2769, 2770, 7, 90, 2, 2, 2770, 2771, 7, 71, 2, 2, 2771, 2772, 7, 85, 2, 2, 2772, 468, 3, 2, 2, 2, 2773, 2774, 7, 75, 2, 2, 2774, 2775, 7, 80, 2, 2, 2775, 2776, 7, 74, 2, 2, 2776, 2777, 7, 71, 2, 2, 2777, 2778, 7, 84, 2, 2, 2778, 2779, 7, 75, 2, 2, 2779, 2780, 7, 86, 2, 2, 2780, 470, 3, 2, 2, 2, 2781, 2782, 7, 75, 2, 2, 2782, 2783, 7, 80, 2, 2, 2783, 2784, 7, 74, 2, 2, 2784, 2785, 7, 71, 2, 2, 2785, 2786, 7, 84, 2, 2, 2786, 2787, 7, 75, 2, 2, 2787, 2788, 7, 86, 2, 2, 2788, 2789, 7, 85, 2, 2, 2789, 472, 3, 2, 2, 2, 2790, 2791, 7, 75, 2, 2, 2791, 2792, 7, 80, 2, 2, 2792, 2793, 7, 78, 2, 2, 2793, 2794, 7, 75, 2, 2, 2794, 2795, 7, 80, 2, 2, 2795, 2796, 7, 71, 2, 2, 2796, 474, 3, 2, 2, 2, 2797, 2798, 7, 75, 2, 2, 2798, 2799, 7, 80, 2, 2, 2799, 2800, 7, 85, 2, 2, 2800, 2801, 7, 71, 2, 2, 2801, 2802, 7, 80, 2, 2, 2802, 2803, 7, 85, 2, 2, 2803, 2804, 7, 75, 2, 2, 2804, 2805, 7, 86, 2, 2, 2805, 2806, 7, 75, 2, 2, 2806, 2807, 7, 88, 2, 2, 2807, 2808, 7, 71, 2, 2, 2808, 476, 3, 2, 2, 2, 2809, 2810, 7, 75, 2, 2, 2810, 2811, 7, 80, 2, 2, 2811, 2812, 7, 85, 2, 2, 2812, 2813, 7, 71, 2, 2, 2813, 2814, 7, 84, 2, 2, 2814, 2815, 7, 86, 2, 2, 2815, 478, 3, 2, 2, 2, 2816, 2817, 7, 75, 2, 2, 2817, 2818, 7, 80, 2, 2, 2818, 2819, 7, 85, 2, 2, 2819, 2820, 7, 86, 2, 2, 2820, 2821, 7, 71, 2, 2, 2821, 2822, 7, 67, 2, 2, 2822, 2823, 7, 70, 2, 2, 2823, 480, 3, 2, 2, 2, 2824, 2825, 7, 75, 2, 2, 2825, 2826, 7, 80, 2, 2, 2826, 2827, 7, 88, 2, 2, 2827, 2828, 7, 81, 2, 2, 2828, 2829, 7, 77, 2, 2, 2829, 2830, 7, 71, 2, 2, 2830, 2831, 7, 84, 2, 2, 2831, 482, 3, 2, 2, 2, 2832, 2833, 7, 75, 2, 2, 2833, 2834, 7, 85, 2, 2, 2834, 2835, 7, 81, 2, 2, 2835, 2836, 7, 78, 2, 2, 2836, 2837, 7, 67, 2, 2, 2837, 2838, 7, 86, 2, 2, 2838, 2839, 7, 75, 2, 2, 2839, 2840, 7, 81, 2, 2, 2840, 2841, 7, 80, 2, 2, 2841, 484, 3, 2, 2, 2, 2842, 2843, 7, 77, 2, 2, 2843, 2844, 7, 71, 2, 2, 2844, 2845, 7, 91, 2, 2, 2845, 486, 3, 2, 2, 2, 2846, 2847, 7, 78, 2, 2, 2847, 2848, 7, 67, 2, 2, 2848, 2849, 7, 68, 2, 2, 2849, 2850, 7, 71, 2, 2, 2850, 2851, 7, 78, 2, 2, 2851, 488, 3, 2, 2, 2, 2852, 2853, 7, 78, 2, 2, 2853, 2854, 7, 67, 2, 2, 2854, 2855, 7, 80, 2, 2, 2855, 2856, 7, 73, 2, 2, 2856, 2857, 7, 87, 2, 2, 2857, 2858, 7, 67, 2, 2, 2858, 2859, 7, 73, 2, 2, 2859, 2860, 7, 71, 2, 2, 2860, 490, 3, 2, 2, 2, 2861, 2862, 7, 78, 2, 2, 2862, 2863, 7, 67, 2, 2, 2863, 2864, 7, 84, 2, 2, 2864, 2865, 7, 73, 2, 2, 2865, 2866, 7, 71, 2, 2, 2866, 492, 3, 2, 2, 2, 2867, 2868, 7, 78, 2, 2, 2868, 2869, 7, 67, 2, 2, 2869, 2870, 7, 85, 2, 2, 2870, 2871, 7, 86, 2, 2, 2871, 494, 3, 2, 2, 2, 2872, 2873, 7, 78, 2, 2, 2873, 2874, 7, 71, 2, 2, 2874, 2875, 7, 67, 2, 2, 2875, 2876, 7, 77, 2, 2, 2876, 2877, 7, 82, 2, 2, 2877, 2878, 7, 84, 2, 2, 2878, 2879, 7, 81, 2, 2, 2879, 2880, 7, 81, 2, 2, 2880, 2881, 7, 72, 2, 2, 2881, 496, 3, 2, 2, 2, 2882, 2883, 7, 78, 2, 2, 2883, 2884, 7, 71, 2, 2, 2884, 2885, 7, 88, 2, 2, 2885, 2886, 7, 71, 2, 2, 2886, 2887, 7, 78, 2, 2, 2887, 498, 3, 2, 2, 2, 2888, 2889, 7, 78, 2, 2, 2889, 2890, 7, 75, 2, 2, 2890, 2891, 7, 85, 2, 2, 2891, 2892, 7, 86, 2, 2, 2892, 2893, 7, 71, 2, 2, 2893, 2894, 7, 80, 2, 2, 2894, 500, 3, 2, 2, 2, 2895, 2896, 7, 78, 2, 2, 2896, 2897, 7, 81, 2, 2, 2897, 2898, 7, 67, 2, 2, 2898, 2899, 7, 70, 2, 2, 2899, 502, 3, 2, 2, 2, 2900, 2901, 7, 78, 2, 2, 2901, 2902, 7, 81, 2, 2, 2902, 2903, 7, 69, 2, 2, 2903, 2904, 7, 67, 2, 2, 2904, 2905, 7, 78, 2, 2, 2905, 504, 3, 2, 2, 2, 2906, 2907, 7, 78, 2, 2, 2907, 2908, 7, 81, 2, 2, 2908, 2909, 7, 69, 2, 2, 2909, 2910, 7, 67, 2, 2, 2910, 2911, 7, 86, 2, 2, 2911, 2912, 7, 75, 2, 2, 2912, 2913, 7, 81, 2, 2, 2913, 2914, 7, 80, 2, 2, 2914, 506, 3, 2, 2, 2, 2915, 2916, 7, 78, 2, 2, 2916, 2917, 7, 81, 2, 2, 2917, 2918, 7, 69, 2, 2, 2918, 2919, 7, 77, 2, 2, 2919, 508, 3, 2, 2, 2, 2920, 2921, 7, 79, 2, 2, 2921, 2922, 7, 67, 2, 2, 2922, 2923, 7, 82, 2, 2, 2923, 2924, 7, 82, 2, 2, 2924, 2925, 7, 75, 2, 2, 2925, 2926, 7, 80, 2, 2, 2926, 2927, 7, 73, 2, 2, 2927, 510, 3, 2, 2, 2, 2928, 2929, 7, 79, 2, 2, 2929, 2930, 7, 67, 2, 2, 2930, 2931, 7, 86, 2, 2, 2931, 2932, 7, 69, 2, 2, 2932, 2933, 7, 74, 2, 2, 2933, 512, 3, 2, 2, 2, 2934, 2935, 7, 79, 2, 2, 2935, 2936, 7, 67, 2, 2, 2936, 2937, 7, 86, 2, 2, 2937, 2938, 7, 71, 2, 2, 2938, 2939, 7, 84, 2, 2, 2939, 2940, 7, 75, 2, 2, 2940, 2941, 7, 67, 2, 2, 2941, 2942, 7, 78, 2, 2, 2942, 2943, 7, 75, 2, 2, 2943, 2944, 7, 92, 2, 2, 2944, 2945, 7, 71, 2, 2, 2945, 2946, 7, 70, 2, 2, 2946, 514, 3, 2, 2, 2, 2947, 2948, 7, 79, 2, 2, 2948, 2949, 7, 67, 2, 2, 2949, 2950, 7, 90, 2, 2, 2950, 2951, 7, 88, 2, 2, 2951, 2952, 7, 67, 2, 2, 2952, 2953, 7, 78, 2, 2, 2953, 2954, 7, 87, 2, 2, 2954, 2955, 7, 71, 2, 2, 2955, 516, 3, 2, 2, 2, 2956, 2957, 7, 79, 2, 2, 2957, 2958, 7, 75, 2, 2, 2958, 2959, 7, 80, 2, 2, 2959, 2960, 7, 87, 2, 2, 2960, 2961, 7, 86, 2, 2, 2961, 2962, 7, 71, 2, 2, 2962, 518, 3, 2, 2, 2, 2963, 2964, 7, 79, 2, 2, 2964, 2965, 7, 75, 2, 2, 2965, 2966, 7, 80, 2, 2, 2966, 2967, 7, 88, 2, 2, 2967, 2968, 7, 67, 2, 2, 2968, 2969, 7, 78, 2, 2, 2969, 2970, 7, 87, 2, 2, 2970, 2971, 7, 71, 2, 2, 2971, 520, 3, 2, 2, 2, 2972, 2973, 7, 79, 2, 2, 2973, 2974, 7, 81, 2, 2, 2974, 2975, 7, 70, 2, 2, 2975, 2976, 7, 71, 2, 2, 2976, 522, 3, 2, 2, 2, 2977, 2978, 7, 79, 2, 2, 2978, 2979, 7, 81, 2, 2, 2979, 2980, 7, 80, 2, 2, 2980, 2981, 7, 86, 2, 2, 2981, 2982, 7, 74, 2, 2, 2982, 524, 3, 2, 2, 2, 2983, 2984, 7, 79, 2, 2, 2984, 2985, 7, 81, 2, 2, 2985, 2986, 7, 88, 2, 2, 2986, 2987, 7, 71, 2, 2, 2987, 526, 3, 2, 2, 2, 2988, 2989, 7, 80, 2, 2, 2989, 2990, 7, 67, 2, 2, 2990, 2991, 7, 79, 2, 2, 2991, 2992, 7, 71, 2, 2, 2992, 528, 3, 2, 2, 2, 2993, 2994, 7, 80, 2, 2, 2994, 2995, 7, 67, 2, 2, 2995, 2996, 7, 79, 2, 2, 2996, 2997, 7, 71, 2, 2, 2997, 2998, 7, 85, 2, 2, 2998, 530, 3, 2, 2, 2, 2999, 3000, 7, 80, 2, 2, 3000, 3001, 7, 71, 2, 2, 3001, 3002, 7, 90, 2, 2, 3002, 3003, 7, 86, 2, 2, 3003, 532, 3, 2, 2, 2, 3004, 3005, 7, 80, 2, 2, 3005, 3006, 7, 81, 2, 2, 3006, 534, 3, 2, 2, 2, 3007, 3008, 7, 80, 2, 2, 3008, 3009, 7, 81, 2, 2, 3009, 3010, 7, 86, 2, 2, 3010, 3011, 7, 74, 2, 2, 3011, 3012, 7, 75, 2, 2, 3012, 3013, 7, 80, 2, 2, 3013, 3014, 7, 73, 2, 2, 3014, 536, 3, 2, 2, 2, 3015, 3016, 7, 80, 2, 2, 3016, 3017, 7, 81, 2, 2, 3017, 3018, 7, 86, 2, 2, 3018, 3019, 7, 75, 2, 2, 3019, 3020, 7, 72, 2, 2, 3020, 3021, 7, 91, 2, 2, 3021, 538, 3, 2, 2, 2, 3022, 3023, 7, 80, 2, 2, 3023, 3024, 7, 81, 2, 2, 3024, 3025, 7, 89, 2, 2, 3025, 3026, 7, 67, 2, 2, 3026, 3027, 7, 75, 2, 2, 3027, 3028, 7, 86, 2, 2, 3028, 540, 3, 2, 2, 2, 3029, 3030, 7, 80, 2, 2, 3030, 3031, 7, 87, 2, 2, 3031, 3032, 7, 78, 2, 2, 3032, 3033, 7, 78, 2, 2, 3033, 3034, 7, 85, 2, 2, 3034, 542, 3, 2, 2, 2, 3035, 3036, 7, 81, 2, 2, 3036, 3037, 7, 68, 2, 2, 3037, 3038, 7, 76, 2, 2, 3038, 3039, 7, 71, 2, 2, 3039, 3040, 7, 69, 2, 2, 3040, 3041, 7, 86, 2, 2, 3041, 544, 3, 2, 2, 2, 3042, 3043, 7, 81, 2, 2, 3043, 3044, 7, 72, 2, 2, 3044, 546, 3, 2, 2, 2, 3045, 3046, 7, 81, 2, 2, 3046, 3047, 7, 72, 2, 2, 3047, 3048, 7, 72, 2, 2, 3048, 548, 3, 2, 2, 2, 3049, 3050, 7, 81, 2, 2, 3050, 3051, 7, 75, 2, 2, 3051, 3052, 7, 70, 2, 2, 3052, 3053, 7, 85, 2, 2, 3053, 550, 3, 2, 2, 2, 3054, 3055, 7, 81, 2, 2, 3055, 3056, 7, 82, 2, 2, 3056, 3057, 7, 71, 2, 2, 3057, 3058, 7, 84, 2, 2, 3058, 3059, 7, 67, 2, 2, 3059, 3060, 7, 86, 2, 2, 3060, 3061, 7, 81, 2, 2, 3061, 3062, 7, 84, 2, 2, 3062, 552, 3, 2, 2, 2, 3063, 3064, 7, 81, 2, 2, 3064, 3065, 7, 82, 2, 2, 3065, 3066, 7, 86, 2, 2, 3066, 3067, 7, 75, 2, 2, 3067, 3068, 7, 81, 2, 2, 3068, 3069, 7, 80, 2, 2, 3069, 554, 3, 2, 2, 2, 3070, 3071, 7, 81, 2, 2, 3071, 3072, 7, 82, 2, 2, 3072, 3073, 7, 86, 2, 2, 3073, 3074, 7, 75, 2, 2, 3074, 3075, 7, 81, 2, 2, 3075, 3076, 7, 80, 2, 2, 3076, 3077, 7, 85, 2, 2, 3077, 556, 3, 2, 2, 2, 3078, 3079, 7, 81, 2, 2, 3079, 3080, 7, 89, 2, 2, 3080, 3081, 7, 80, 2, 2, 3081, 3082, 7, 71, 2, 2, 3082, 3083, 7, 70, 2, 2, 3083, 558, 3, 2, 2, 2, 3084, 3085, 7, 81, 2, 2, 3085, 3086, 7, 89, 2, 2, 3086, 3087, 7, 80, 2, 2, 3087, 3088, 7, 71, 2, 2, 3088, 3089, 7, 84, 2, 2, 3089, 560, 3, 2, 2, 2, 3090, 3091, 7, 82, 2, 2, 3091, 3092, 7, 67, 2, 2, 3092, 3093, 7, 84, 2, 2, 3093, 3094, 7, 85, 2, 2, 3094, 3095, 7, 71, 2, 2, 3095, 3096, 7, 84, 2, 2, 3096, 562, 3, 2, 2, 2, 3097, 3098, 7, 82, 2, 2, 3098, 3099, 7, 67, 2, 2, 3099, 3100, 7, 84, 2, 2, 3100, 3101, 7, 86, 2, 2, 3101, 3102, 7, 75, 2, 2, 3102, 3103, 7, 67, 2, 2, 3103, 3104, 7, 78, 2, 2, 3104, 564, 3, 2, 2, 2, 3105, 3106, 7, 82, 2, 2, 3106, 3107, 7, 67, 2, 2, 3107, 3108, 7, 84, 2, 2, 3108, 3109, 7, 86, 2, 2, 3109, 3110, 7, 75, 2, 2, 3110, 3111, 7, 86, 2, 2, 3111, 3112, 7, 75, 2, 2, 3112, 3113, 7, 81, 2, 2, 3113, 3114, 7, 80, 2, 2, 3114, 566, 3, 2, 2, 2, 3115, 3116, 7, 82, 2, 2, 3116, 3117, 7, 67, 2, 2, 3117, 3118, 7, 85, 2, 2, 3118, 3119, 7, 85, 2, 2, 3119, 3120, 7, 75, 2, 2, 3120, 3121, 7, 80, 2, 2, 3121, 3122, 7, 73, 2, 2, 3122, 568, 3, 2, 2, 2, 3123, 3124, 7, 82, 2, 2, 3124, 3125, 7, 67, 2, 2, 3125, 3126, 7, 85, 2, 2, 3126, 3127, 7, 85, 2, 2, 3127, 3128, 7, 89, 2, 2, 3128, 3129, 7, 81, 2, 2, 3129, 3130, 7, 84, 2, 2, 3130, 3131, 7, 70, 2, 2, 3131, 570, 3, 2, 2, 2, 3132, 3133, 7, 82, 2, 2, 3133, 3134, 7, 78, 2, 2, 3134, 3135, 7, 67, 2, 2, 3135, 3136, 7, 80, 2, 2, 3136, 3137, 7, 85, 2, 2, 3137, 572, 3, 2, 2, 2, 3138, 3139, 7, 82, 2, 2, 3139, 3140, 7, 84, 2, 2, 3140, 3141, 7, 71, 2, 2, 3141, 3142, 7, 69, 2, 2, 3142, 3143, 7, 71, 2, 2, 3143, 3144, 7, 70, 2, 2, 3144, 3145, 7, 75, 2, 2, 3145, 3146, 7, 80, 2, 2, 3146, 3147, 7, 73, 2, 2, 3147, 574, 3, 2, 2, 2, 3148, 3149, 7, 82, 2, 2, 3149, 3150, 7, 84, 2, 2, 3150, 3151, 7, 71, 2, 2, 3151, 3152, 7, 82, 2, 2, 3152, 3153, 7, 67, 2, 2, 3153, 3154, 7, 84, 2, 2, 3154, 3155, 7, 71, 2, 2, 3155, 576, 3, 2, 2, 2, 3156, 3157, 7, 82, 2, 2, 3157, 3158, 7, 84, 2, 2, 3158, 3159, 7, 71, 2, 2, 3159, 3160, 7, 82, 2, 2, 3160, 3161, 7, 67, 2, 2, 3161, 3162, 7, 84, 2, 2, 3162, 3163, 7, 71, 2, 2, 3163, 3164, 7, 70, 2, 2, 3164, 578, 3, 2, 2, 2, 3165, 3166, 7, 82, 2, 2, 3166, 3167, 7, 84, 2, 2, 3167, 3168, 7, 71, 2, 2, 3168, 3169, 7, 85, 2, 2, 3169, 3170, 7, 71, 2, 2, 3170, 3171, 7, 84, 2, 2, 3171, 3172, 7, 88, 2, 2, 3172, 3173, 7, 71, 2, 2, 3173, 580, 3, 2, 2, 2, 3174, 3175, 7, 82, 2, 2, 3175, 3176, 7, 84, 2, 2, 3176, 3177, 7, 75, 2, 2, 3177, 3178, 7, 81, 2, 2, 3178, 3179, 7, 84, 2, 2, 3179, 582, 3, 2, 2, 2, 3180, 3181, 7, 82, 2, 2, 3181, 3182, 7, 84, 2, 2, 3182, 3183, 7, 75, 2, 2, 3183, 3184, 7, 88, 2, 2, 3184, 3185, 7, 75, 2, 2, 3185, 3186, 7, 78, 2, 2, 3186, 3187, 7, 71, 2, 2, 3187, 3188, 7, 73, 2, 2, 3188, 3189, 7, 71, 2, 2, 3189, 3190, 7, 85, 2, 2, 3190, 584, 3, 2, 2, 2, 3191, 3192, 7, 82, 2, 2, 3192, 3193, 7, 84, 2, 2, 3193, 3194, 7, 81, 2, 2, 3194, 3195, 7, 69, 2, 2, 3195, 3196, 7, 71, 2, 2, 3196, 3197, 7, 70, 2, 2, 3197, 3198, 7, 87, 2, 2, 3198, 3199, 7, 84, 2, 2, 3199, 3200, 7, 67, 2, 2, 3200, 3201, 7, 78, 2, 2, 3201, 586, 3, 2, 2, 2, 3202, 3203, 7, 82, 2, 2, 3203, 3204, 7, 84, 2, 2, 3204, 3205, 7, 81, 2, 2, 3205, 3206, 7, 69, 2, 2, 3206, 3207, 7, 71, 2, 2, 3207, 3208, 7, 70, 2, 2, 3208, 3209, 7, 87, 2, 2, 3209, 3210, 7, 84, 2, 2, 3210, 3211, 7, 71, 2, 2, 3211, 588, 3, 2, 2, 2, 3212, 3213, 7, 82, 2, 2, 3213, 3214, 7, 84, 2, 2, 3214, 3215, 7, 81, 2, 2, 3215, 3216, 7, 73, 2, 2, 3216, 3217, 7, 84, 2, 2, 3217, 3218, 7, 67, 2, 2, 3218, 3219, 7, 79, 2, 2, 3219, 590, 3, 2, 2, 2, 3220, 3221, 7, 83, 2, 2, 3221, 3222, 7, 87, 2, 2, 3222, 3223, 7, 81, 2, 2, 3223, 3224, 7, 86, 2, 2, 3224, 3225, 7, 71, 2, 2, 3225, 592, 3, 2, 2, 2, 3226, 3227, 7, 84, 2, 2, 3227, 3228, 7, 67, 2, 2, 3228, 3229, 7, 80, 2, 2, 3229, 3230, 7, 73, 2, 2, 3230, 3231, 7, 71, 2, 2, 3231, 594, 3, 2, 2, 2, 3232, 3233, 7, 84, 2, 2, 3233, 3234, 7, 71, 2, 2, 3234, 3235, 7, 67, 2, 2, 3235, 3236, 7, 70, 2, 2, 3236, 596, 3, 2, 2, 2, 3237, 3238, 7, 84, 2, 2, 3238, 3239, 7, 71, 2, 2, 3239, 3240, 7, 67, 2, 2, 3240, 3241, 7, 85, 2, 2, 3241, 3242, 7, 85, 2, 2, 3242, 3243, 7, 75, 2, 2, 3243, 3244, 7, 73, 2, 2, 3244, 3245, 7, 80, 2, 2, 3245, 598, 3, 2, 2, 2, 3246, 3247, 7, 84, 2, 2, 3247, 3248, 7, 71, 2, 2, 3248, 3249, 7, 69, 2, 2, 3249, 3250, 7, 74, 2, 2, 3250, 3251, 7, 71, 2, 2, 3251, 3252, 7, 69, 2, 2, 3252, 3253, 7, 77, 2, 2, 3253, 600, 3, 2, 2, 2, 3254, 3255, 7, 84, 2, 2, 3255, 3256, 7, 71, 2, 2, 3256, 3257, 7, 69, 2, 2, 3257, 3258, 7, 87, 2, 2, 3258, 3259, 7, 84, 2, 2, 3259, 3260, 7, 85, 2, 2, 3260, 3261, 7, 75, 2, 2, 3261, 3262, 7, 88, 2, 2, 3262, 3263, 7, 71, 2, 2, 3263, 602, 3, 2, 2, 2, 3264, 3265, 7, 84, 2, 2, 3265, 3266, 7, 71, 2, 2, 3266, 3267, 7, 72, 2, 2, 3267, 604, 3, 2, 2, 2, 3268, 3269, 7, 84, 2, 2, 3269, 3270, 7, 71, 2, 2, 3270, 3271, 7, 72, 2, 2, 3271, 3272, 7, 84, 2, 2, 3272, 3273, 7, 71, 2, 2, 3273, 3274, 7, 85, 2, 2, 3274, 3275, 7, 74, 2, 2, 3275, 606, 3, 2, 2, 2, 3276, 3277, 7, 84, 2, 2, 3277, 3278, 7, 71, 2, 2, 3278, 3279, 7, 75, 2, 2, 3279, 3280, 7, 80, 2, 2, 3280, 3281, 7, 70, 2, 2, 3281, 3282, 7, 71, 2, 2, 3282, 3283, 7, 90, 2, 2, 3283, 608, 3, 2, 2, 2, 3284, 3285, 7, 84, 2, 2, 3285, 3286, 7, 71, 2, 2, 3286, 3287, 7, 78, 2, 2, 3287, 3288, 7, 67, 2, 2, 3288, 3289, 7, 86, 2, 2, 3289, 3290, 7, 75, 2, 2, 3290, 3291, 7, 88, 2, 2, 3291, 3292, 7, 71, 2, 2, 3292, 610, 3, 2, 2, 2, 3293, 3294, 7, 84, 2, 2, 3294, 3295, 7, 71, 2, 2, 3295, 3296, 7, 78, 2, 2, 3296, 3297, 7, 71, 2, 2, 3297, 3298, 7, 67, 2, 2, 3298, 3299, 7, 85, 2, 2, 3299, 3300, 7, 71, 2, 2, 3300, 612, 3, 2, 2, 2, 3301, 3302, 7, 84, 2, 2, 3302, 3303, 7, 71, 2, 2, 3303, 3304, 7, 80, 2, 2, 3304, 3305, 7, 67, 2, 2, 3305, 3306, 7, 79, 2, 2, 3306, 3307, 7, 71, 2, 2, 3307, 614, 3, 2, 2, 2, 3308, 3309, 7, 84, 2, 2, 3309, 3310, 7, 71, 2, 2, 3310, 3311, 7, 82, 2, 2, 3311, 3312, 7, 71, 2, 2, 3312, 3313, 7, 67, 2, 2, 3313, 3314, 7, 86, 2, 2, 3314, 3315, 7, 67, 2, 2, 3315, 3316, 7, 68, 2, 2, 3316, 3317, 7, 78, 2, 2, 3317, 3318, 7, 71, 2, 2, 3318, 616, 3, 2, 2, 2, 3319, 3320, 7, 84, 2, 2, 3320, 3321, 7, 71, 2, 2, 3321, 3322, 7, 82, 2, 2, 3322, 3323, 7, 78, 2, 2, 3323, 3324, 7, 67, 2, 2, 3324, 3325, 7, 69, 2, 2, 3325, 3326, 7, 71, 2, 2, 3326, 618, 3, 2, 2, 2, 3327, 3328, 7, 84, 2, 2, 3328, 3329, 7, 71, 2, 2, 3329, 3330, 7, 82, 2, 2, 3330, 3331, 7, 78, 2, 2, 3331, 3332, 7, 75, 2, 2, 3332, 3333, 7, 69, 2, 2, 3333, 3334, 7, 67, 2, 2, 3334, 620, 3, 2, 2, 2, 3335, 3336, 7, 84, 2, 2, 3336, 3337, 7, 71, 2, 2, 3337, 3338, 7, 85, 2, 2, 3338, 3339, 7, 71, 2, 2, 3339, 3340, 7, 86, 2, 2, 3340, 622, 3, 2, 2, 2, 3341, 3342, 7, 84, 2, 2, 3342, 3343, 7, 71, 2, 2, 3343, 3344, 7, 85, 2, 2, 3344, 3345, 7, 86, 2, 2, 3345, 3346, 7, 67, 2, 2, 3346, 3347, 7, 84, 2, 2, 3347, 3348, 7, 86, 2, 2, 3348, 624, 3, 2, 2, 2, 3349, 3350, 7, 84, 2, 2, 3350, 3351, 7, 71, 2, 2, 3351, 3352, 7, 85, 2, 2, 3352, 3353, 7, 86, 2, 2, 3353, 3354, 7, 84, 2, 2, 3354, 3355, 7, 75, 2, 2, 3355, 3356, 7, 69, 2, 2, 3356, 3357, 7, 86, 2, 2, 3357, 626, 3, 2, 2, 2, 3358, 3359, 7, 84, 2, 2, 3359, 3360, 7, 71, 2, 2, 3360, 3361, 7, 86, 2, 2, 3361, 3362, 7, 87, 2, 2, 3362, 3363, 7, 84, 2, 2, 3363, 3364, 7, 80, 2, 2, 3364, 3365, 7, 85, 2, 2, 3365, 628, 3, 2, 2, 2, 3366, 3367, 7, 84, 2, 2, 3367, 3368, 7, 71, 2, 2, 3368, 3369, 7, 88, 2, 2, 3369, 3370, 7, 81, 2, 2, 3370, 3371, 7, 77, 2, 2, 3371, 3372, 7, 71, 2, 2, 3372, 630, 3, 2, 2, 2, 3373, 3374, 7, 84, 2, 2, 3374, 3375, 7, 81, 2, 2, 3375, 3376, 7, 78, 2, 2, 3376, 3377, 7, 71, 2, 2, 3377, 632, 3, 2, 2, 2, 3378, 3379, 7, 84, 2, 2, 3379, 3380, 7, 81, 2, 2, 3380, 3381, 7, 78, 2, 2, 3381, 3382, 7, 78, 2, 2, 3382, 3383, 7, 68, 2, 2, 3383, 3384, 7, 67, 2, 2, 3384, 3385, 7, 69, 2, 2, 3385, 3386, 7, 77, 2, 2, 3386, 634, 3, 2, 2, 2, 3387, 3388, 7, 84, 2, 2, 3388, 3389, 7, 81, 2, 2, 3389, 3390, 7, 89, 2, 2, 3390, 3391, 7, 85, 2, 2, 3391, 636, 3, 2, 2, 2, 3392, 3393, 7, 84, 2, 2, 3393, 3394, 7, 87, 2, 2, 3394, 3395, 7, 78, 2, 2, 3395, 3396, 7, 71, 2, 2, 3396, 638, 3, 2, 2, 2, 3397, 3398, 7, 85, 2, 2, 3398, 3399, 7, 67, 2, 2, 3399, 3400, 7, 88, 2, 2, 3400, 3401, 7, 71, 2, 2, 3401, 3402, 7, 82, 2, 2, 3402, 3403, 7, 81, 2, 2, 3403, 3404, 7, 75, 2, 2, 3404, 3405, 7, 80, 2, 2, 3405, 3406, 7, 86, 2, 2, 3406, 640, 3, 2, 2, 2, 3407, 3408, 7, 85, 2, 2, 3408, 3409, 7, 69, 2, 2, 3409, 3410, 7, 74, 2, 2, 3410, 3411, 7, 71, 2, 2, 3411, 3412, 7, 79, 2, 2, 3412, 3413, 7, 67, 2, 2, 3413, 642, 3, 2, 2, 2, 3414, 3415, 7, 85, 2, 2, 3415, 3416, 7, 69, 2, 2, 3416, 3417, 7, 84, 2, 2, 3417, 3418, 7, 81, 2, 2, 3418, 3419, 7, 78, 2, 2, 3419, 3420, 7, 78, 2, 2, 3420, 644, 3, 2, 2, 2, 3421, 3422, 7, 85, 2, 2, 3422, 3423, 7, 71, 2, 2, 3423, 3424, 7, 67, 2, 2, 3424, 3425, 7, 84, 2, 2, 3425, 3426, 7, 69, 2, 2, 3426, 3427, 7, 74, 2, 2, 3427, 646, 3, 2, 2, 2, 3428, 3429, 7, 85, 2, 2, 3429, 3430, 7, 71, 2, 2, 3430, 3431, 7, 69, 2, 2, 3431, 3432, 7, 81, 2, 2, 3432, 3433, 7, 80, 2, 2, 3433, 3434, 7, 70, 2, 2, 3434, 648, 3, 2, 2, 2, 3435, 3436, 7, 85, 2, 2, 3436, 3437, 7, 71, 2, 2, 3437, 3438, 7, 69, 2, 2, 3438, 3439, 7, 87, 2, 2, 3439, 3440, 7, 84, 2, 2, 3440, 3441, 7, 75, 2, 2, 3441, 3442, 7, 86, 2, 2, 3442, 3443, 7, 91, 2, 2, 3443, 650, 3, 2, 2, 2, 3444, 3445, 7, 85, 2, 2, 3445, 3446, 7, 71, 2, 2, 3446, 3447, 7, 83, 2, 2, 3447, 3448, 7, 87, 2, 2, 3448, 3449, 7, 71, 2, 2, 3449, 3450, 7, 80, 2, 2, 3450, 3451, 7, 69, 2, 2, 3451, 3452, 7, 71, 2, 2, 3452, 652, 3, 2, 2, 2, 3453, 3454, 7, 85, 2, 2, 3454, 3455, 7, 71, 2, 2, 3455, 3456, 7, 83, 2, 2, 3456, 3457, 7, 87, 2, 2, 3457, 3458, 7, 71, 2, 2, 3458, 3459, 7, 80, 2, 2, 3459, 3460, 7, 69, 2, 2, 3460, 3461, 7, 71, 2, 2, 3461, 3462, 7, 85, 2, 2, 3462, 654, 3, 2, 2, 2, 3463, 3464, 7, 85, 2, 2, 3464, 3465, 7, 71, 2, 2, 3465, 3466, 7, 84, 2, 2, 3466, 3467, 7, 75, 2, 2, 3467, 3468, 7, 67, 2, 2, 3468, 3469, 7, 78, 2, 2, 3469, 3470, 7, 75, 2, 2, 3470, 3471, 7, 92, 2, 2, 3471, 3472, 7, 67, 2, 2, 3472, 3473, 7, 68, 2, 2, 3473, 3474, 7, 78, 2, 2, 3474, 3475, 7, 71, 2, 2, 3475, 656, 3, 2, 2, 2, 3476, 3477, 7, 85, 2, 2, 3477, 3478, 7, 71, 2, 2, 3478, 3479, 7, 84, 2, 2, 3479, 3480, 7, 88, 2, 2, 3480, 3481, 7, 71, 2, 2, 3481, 3482, 7, 84, 2, 2, 3482, 658, 3, 2, 2, 2, 3483, 3484, 7, 85, 2, 2, 3484, 3485, 7, 71, 2, 2, 3485, 3486, 7, 85, 2, 2, 3486, 3487, 7, 85, 2, 2, 3487, 3488, 7, 75, 2, 2, 3488, 3489, 7, 81, 2, 2, 3489, 3490, 7, 80, 2, 2, 3490, 660, 3, 2, 2, 2, 3491, 3492, 7, 85, 2, 2, 3492, 3493, 7, 71, 2, 2, 3493, 3494, 7, 86, 2, 2, 3494, 662, 3, 2, 2, 2, 3495, 3496, 7, 85, 2, 2, 3496, 3497, 7, 74, 2, 2, 3497, 3498, 7, 67, 2, 2, 3498, 3499, 7, 84, 2, 2, 3499, 3500, 7, 71, 2, 2, 3500, 664, 3, 2, 2, 2, 3501, 3502, 7, 85, 2, 2, 3502, 3503, 7, 74, 2, 2, 3503, 3504, 7, 81, 2, 2, 3504, 3505, 7, 89, 2, 2, 3505, 666, 3, 2, 2, 2, 3506, 3507, 7, 85, 2, 2, 3507, 3508, 7, 75, 2, 2, 3508, 3509, 7, 79, 2, 2, 3509, 3510, 7, 82, 2, 2, 3510, 3511, 7, 78, 2, 2, 3511, 3512, 7, 71, 2, 2, 3512, 668, 3, 2, 2, 2, 3513, 3514, 7, 85, 2, 2, 3514, 3515, 7, 80, 2, 2, 3515, 3516, 7, 67, 2, 2, 3516, 3517, 7, 82, 2, 2, 3517, 3518, 7, 85, 2, 2, 3518, 3519, 7, 74, 2, 2, 3519, 3520, 7, 81, 2, 2, 3520, 3521, 7, 86, 2, 2, 3521, 670, 3, 2, 2, 2, 3522, 3523, 7, 85, 2, 2, 3523, 3524, 7, 86, 2, 2, 3524, 3525, 7, 67, 2, 2, 3525, 3526, 7, 68, 2, 2, 3526, 3527, 7, 78, 2, 2, 3527, 3528, 7, 71, 2, 2, 3528, 672, 3, 2, 2, 2, 3529, 3530, 7, 85, 2, 2, 3530, 3531, 7, 86, 2, 2, 3531, 3532, 7, 67, 2, 2, 3532, 3533, 7, 80, 2, 2, 3533, 3534, 7, 70, 2, 2, 3534, 3535, 7, 67, 2, 2, 3535, 3536, 7, 78, 2, 2, 3536, 3537, 7, 81, 2, 2, 3537, 3538, 7, 80, 2, 2, 3538, 3539, 7, 71, 2, 2, 3539, 674, 3, 2, 2, 2, 3540, 3541, 7, 85, 2, 2, 3541, 3542, 7, 86, 2, 2, 3542, 3543, 7, 67, 2, 2, 3543, 3544, 7, 84, 2, 2, 3544, 3545, 7, 86, 2, 2, 3545, 676, 3, 2, 2, 2, 3546, 3547, 7, 85, 2, 2, 3547, 3548, 7, 86, 2, 2, 3548, 3549, 7, 67, 2, 2, 3549, 3550, 7, 86, 2, 2, 3550, 3551, 7, 71, 2, 2, 3551, 3552, 7, 79, 2, 2, 3552, 3553, 7, 71, 2, 2, 3553, 3554, 7, 80, 2, 2, 3554, 3555, 7, 86, 2, 2, 3555, 678, 3, 2, 2, 2, 3556, 3557, 7, 85, 2, 2, 3557, 3558, 7, 86, 2, 2, 3558, 3559, 7, 67, 2, 2, 3559, 3560, 7, 86, 2, 2, 3560, 3561, 7, 75, 2, 2, 3561, 3562, 7, 85, 2, 2, 3562, 3563, 7, 86, 2, 2, 3563, 3564, 7, 75, 2, 2, 3564, 3565, 7, 69, 2, 2, 3565, 3566, 7, 85, 2, 2, 3566, 680, 3, 2, 2, 2, 3567, 3568, 7, 85, 2, 2, 3568, 3569, 7, 86, 2, 2, 3569, 3570, 7, 70, 2, 2, 3570, 3571, 7, 75, 2, 2, 3571, 3572, 7, 80, 2, 2, 3572, 682, 3, 2, 2, 2, 3573, 3574, 7, 85, 2, 2, 3574, 3575, 7, 86, 2, 2, 3575, 3576, 7, 70, 2, 2, 3576, 3577, 7, 81, 2, 2, 3577, 3578, 7, 87, 2, 2, 3578, 3579, 7, 86, 2, 2, 3579, 684, 3, 2, 2, 2, 3580, 3581, 7, 85, 2, 2, 3581, 3582, 7, 86, 2, 2, 3582, 3583, 7, 81, 2, 2, 3583, 3584, 7, 84, 2, 2, 3584, 3585, 7, 67, 2, 2, 3585, 3586, 7, 73, 2, 2, 3586, 3587, 7, 71, 2, 2, 3587, 686, 3, 2, 2, 2, 3588, 3589, 7, 85, 2, 2, 3589, 3590, 7, 86, 2, 2, 3590, 3591, 7, 84, 2, 2, 3591, 3592, 7, 75, 2, 2, 3592, 3593, 7, 69, 2, 2, 3593, 3594, 7, 86, 2, 2, 3594, 688, 3, 2, 2, 2, 3595, 3596, 7, 85, 2, 2, 3596, 3597, 7, 86, 2, 2, 3597, 3598, 7, 84, 2, 2, 3598, 3599, 7, 75, 2, 2, 3599, 3600, 7, 82, 2, 2, 3600, 690, 3, 2, 2, 2, 3601, 3602, 7, 85, 2, 2, 3602, 3603, 7, 91, 2, 2, 3603, 3604, 7, 85, 2, 2, 3604, 3605, 7, 75, 2, 2, 3605, 3606, 7, 70, 2, 2, 3606, 692, 3, 2, 2, 2, 3607, 3608, 7, 85, 2, 2, 3608, 3609, 7, 91, 2, 2, 3609, 3610, 7, 85, 2, 2, 3610, 3611, 7, 86, 2, 2, 3611, 3612, 7, 71, 2, 2, 3612, 3613, 7, 79, 2, 2, 3613, 694, 3, 2, 2, 2, 3614, 3615, 7, 86, 2, 2, 3615, 3616, 7, 67, 2, 2, 3616, 3617, 7, 68, 2, 2, 3617, 3618, 7, 78, 2, 2, 3618, 3619, 7, 71, 2, 2, 3619, 3620, 7, 85, 2, 2, 3620, 696, 3, 2, 2, 2, 3621, 3622, 7, 86, 2, 2, 3622, 3623, 7, 67, 2, 2, 3623, 3624, 7, 68, 2, 2, 3624, 3625, 7, 78, 2, 2, 3625, 3626, 7, 71, 2, 2, 3626, 3627, 7, 85, 2, 2, 3627, 3628, 7, 82, 2, 2, 3628, 3629, 7, 67, 2, 2, 3629, 3630, 7, 69, 2, 2, 3630, 3631, 7, 71, 2, 2, 3631, 698, 3, 2, 2, 2, 3632, 3633, 7, 86, 2, 2, 3633, 3634, 7, 71, 2, 2, 3634, 3635, 7, 79, 2, 2, 3635, 3636, 7, 82, 2, 2, 3636, 700, 3, 2, 2, 2, 3637, 3638, 7, 86, 2, 2, 3638, 3639, 7, 71, 2, 2, 3639, 3640, 7, 79, 2, 2, 3640, 3641, 7, 82, 2, 2, 3641, 3642, 7, 78, 2, 2, 3642, 3643, 7, 67, 2, 2, 3643, 3644, 7, 86, 2, 2, 3644, 3645, 7, 71, 2, 2, 3645, 702, 3, 2, 2, 2, 3646, 3647, 7, 86, 2, 2, 3647, 3648, 7, 71, 2, 2, 3648, 3649, 7, 79, 2, 2, 3649, 3650, 7, 82, 2, 2, 3650, 3651, 7, 81, 2, 2, 3651, 3652, 7, 84, 2, 2, 3652, 3653, 7, 67, 2, 2, 3653, 3654, 7, 84, 2, 2, 3654, 3655, 7, 91, 2, 2, 3655, 704, 3, 2, 2, 2, 3656, 3657, 7, 86, 2, 2, 3657, 3658, 7, 71, 2, 2, 3658, 3659, 7, 90, 2, 2, 3659, 3660, 7, 86, 2, 2, 3660, 706, 3, 2, 2, 2, 3661, 3662, 7, 86, 2, 2, 3662, 3663, 7, 84, 2, 2, 3663, 3664, 7, 67, 2, 2, 3664, 3665, 7, 80, 2, 2, 3665, 3666, 7, 85, 2, 2, 3666, 3667, 7, 67, 2, 2, 3667, 3668, 7, 69, 2, 2, 3668, 3669, 7, 86, 2, 2, 3669, 3670, 7, 75, 2, 2, 3670, 3671, 7, 81, 2, 2, 3671, 3672, 7, 80, 2, 2, 3672, 708, 3, 2, 2, 2, 3673, 3674, 7, 86, 2, 2, 3674, 3675, 7, 84, 2, 2, 3675, 3676, 7, 75, 2, 2, 3676, 3677, 7, 73, 2, 2, 3677, 3678, 7, 73, 2, 2, 3678, 3679, 7, 71, 2, 2, 3679, 3680, 7, 84, 2, 2, 3680, 710, 3, 2, 2, 2, 3681, 3682, 7, 86, 2, 2, 3682, 3683, 7, 84, 2, 2, 3683, 3684, 7, 87, 2, 2, 3684, 3685, 7, 80, 2, 2, 3685, 3686, 7, 69, 2, 2, 3686, 3687, 7, 67, 2, 2, 3687, 3688, 7, 86, 2, 2, 3688, 3689, 7, 71, 2, 2, 3689, 712, 3, 2, 2, 2, 3690, 3691, 7, 86, 2, 2, 3691, 3692, 7, 84, 2, 2, 3692, 3693, 7, 87, 2, 2, 3693, 3694, 7, 85, 2, 2, 3694, 3695, 7, 86, 2, 2, 3695, 3696, 7, 71, 2, 2, 3696, 3697, 7, 70, 2, 2, 3697, 714, 3, 2, 2, 2, 3698, 3699, 7, 86, 2, 2, 3699, 3700, 7, 91, 2, 2, 3700, 3701, 7, 82, 2, 2, 3701, 3702, 7, 71, 2, 2, 3702, 716, 3, 2, 2, 2, 3703, 3704, 7, 86, 2, 2, 3704, 3705, 7, 91, 2, 2, 3705, 3706, 7, 82, 2, 2, 3706, 3707, 7, 71, 2, 2, 3707, 3708, 7, 85, 2, 2, 3708, 718, 3, 2, 2, 2, 3709, 3710, 7, 87, 2, 2, 3710, 3711, 7, 80, 2, 2, 3711, 3712, 7, 68, 2, 2, 3712, 3713, 7, 81, 2, 2, 3713, 3714, 7, 87, 2, 2, 3714, 3715, 7, 80, 2, 2, 3715, 3716, 7, 70, 2, 2, 3716, 3717, 7, 71, 2, 2, 3717, 3718, 7, 70, 2, 2, 3718, 720, 3, 2, 2, 2, 3719, 3720, 7, 87, 2, 2, 3720, 3721, 7, 80, 2, 2, 3721, 3722, 7, 69, 2, 2, 3722, 3723, 7, 81, 2, 2, 3723, 3724, 7, 79, 2, 2, 3724, 3725, 7, 79, 2, 2, 3725, 3726, 7, 75, 2, 2, 3726, 3727, 7, 86, 2, 2, 3727, 3728, 7, 86, 2, 2, 3728, 3729, 7, 71, 2, 2, 3729, 3730, 7, 70, 2, 2, 3730, 722, 3, 2, 2, 2, 3731, 3732, 7, 87, 2, 2, 3732, 3733, 7, 80, 2, 2, 3733, 3734, 7, 71, 2, 2, 3734, 3735, 7, 80, 2, 2, 3735, 3736, 7, 69, 2, 2, 3736, 3737, 7, 84, 2, 2, 3737, 3738, 7, 91, 2, 2, 3738, 3739, 7, 82, 2, 2, 3739, 3740, 7, 86, 2, 2, 3740, 3741, 7, 71, 2, 2, 3741, 3742, 7, 70, 2, 2, 3742, 724, 3, 2, 2, 2, 3743, 3744, 7, 87, 2, 2, 3744, 3745, 7, 80, 2, 2, 3745, 3746, 7, 77, 2, 2, 3746, 3747, 7, 80, 2, 2, 3747, 3748, 7, 81, 2, 2, 3748, 3749, 7, 89, 2, 2, 3749, 3750, 7, 80, 2, 2, 3750, 726, 3, 2, 2, 2, 3751, 3752, 7, 87, 2, 2, 3752, 3753, 7, 80, 2, 2, 3753, 3754, 7, 78, 2, 2, 3754, 3755, 7, 75, 2, 2, 3755, 3756, 7, 85, 2, 2, 3756, 3757, 7, 86, 2, 2, 3757, 3758, 7, 71, 2, 2, 3758, 3759, 7, 80, 2, 2, 3759, 728, 3, 2, 2, 2, 3760, 3761, 7, 87, 2, 2, 3761, 3762, 7, 80, 2, 2, 3762, 3763, 7, 78, 2, 2, 3763, 3764, 7, 81, 2, 2, 3764, 3765, 7, 73, 2, 2, 3765, 3766, 7, 73, 2, 2, 3766, 3767, 7, 71, 2, 2, 3767, 3768, 7, 70, 2, 2, 3768, 730, 3, 2, 2, 2, 3769, 3770, 7, 87, 2, 2, 3770, 3771, 7, 80, 2, 2, 3771, 3772, 7, 86, 2, 2, 3772, 3773, 7, 75, 2, 2, 3773, 3774, 7, 78, 2, 2, 3774, 732, 3, 2, 2, 2, 3775, 3776, 7, 87, 2, 2, 3776, 3777, 7, 82, 2, 2, 3777, 3778, 7, 70, 2, 2, 3778, 3779, 7, 67, 2, 2, 3779, 3780, 7, 86, 2, 2, 3780, 3781, 7, 71, 2, 2, 3781, 734, 3, 2, 2, 2, 3782, 3783, 7, 88, 2, 2, 3783, 3784, 7, 67, 2, 2, 3784, 3785, 7, 69, 2, 2, 3785, 3786, 7, 87, 2, 2, 3786, 3787, 7, 87, 2, 2, 3787, 3788, 7, 79, 2, 2, 3788, 736, 3, 2, 2, 2, 3789, 3790, 7, 88, 2, 2, 3790, 3791, 7, 67, 2, 2, 3791, 3792, 7, 78, 2, 2, 3792, 3793, 7, 75, 2, 2, 3793, 3794, 7, 70, 2, 2, 3794, 738, 3, 2, 2, 2, 3795, 3796, 7, 88, 2, 2, 3796, 3797, 7, 67, 2, 2, 3797, 3798, 7, 78, 2, 2, 3798, 3799, 7, 75, 2, 2, 3799, 3800, 7, 70, 2, 2, 3800, 3801, 7, 67, 2, 2, 3801, 3802, 7, 86, 2, 2, 3802, 3803, 7, 71, 2, 2, 3803, 740, 3, 2, 2, 2, 3804, 3805, 7, 88, 2, 2, 3805, 3806, 7, 67, 2, 2, 3806, 3807, 7, 78, 2, 2, 3807, 3808, 7, 75, 2, 2, 3808, 3809, 7, 70, 2, 2, 3809, 3810, 7, 67, 2, 2, 3810, 3811, 7, 86, 2, 2, 3811, 3812, 7, 81, 2, 2, 3812, 3813, 7, 84, 2, 2, 3813, 742, 3, 2, 2, 2, 3814, 3815, 7, 88, 2, 2, 3815, 3816, 7, 67, 2, 2, 3816, 3817, 7, 84, 2, 2, 3817, 3818, 7, 91, 2, 2, 3818, 3819, 7, 75, 2, 2, 3819, 3820, 7, 80, 2, 2, 3820, 3821, 7, 73, 2, 2, 3821, 744, 3, 2, 2, 2, 3822, 3823, 7, 88, 2, 2, 3823, 3824, 7, 71, 2, 2, 3824, 3825, 7, 84, 2, 2, 3825, 3826, 7, 85, 2, 2, 3826, 3827, 7, 75, 2, 2, 3827, 3828, 7, 81, 2, 2, 3828, 3829, 7, 80, 2, 2, 3829, 746, 3, 2, 2, 2, 3830, 3831, 7, 88, 2, 2, 3831, 3832, 7, 75, 2, 2, 3832, 3833, 7, 71, 2, 2, 3833, 3834, 7, 89, 2, 2, 3834, 748, 3, 2, 2, 2, 3835, 3836, 7, 88, 2, 2, 3836, 3837, 7, 81, 2, 2, 3837, 3838, 7, 78, 2, 2, 3838, 3839, 7, 67, 2, 2, 3839, 3840, 7, 86, 2, 2, 3840, 3841, 7, 75, 2, 2, 3841, 3842, 7, 78, 2, 2, 3842, 3843, 7, 71, 2, 2, 3843, 750, 3, 2, 2, 2, 3844, 3845, 7, 89, 2, 2, 3845, 3846, 7, 74, 2, 2, 3846, 3847, 7, 75, 2, 2, 3847, 3848, 7, 86, 2, 2, 3848, 3849, 7, 71, 2, 2, 3849, 3850, 7, 85, 2, 2, 3850, 3851, 7, 82, 2, 2, 3851, 3852, 7, 67, 2, 2, 3852, 3853, 7, 69, 2, 2, 3853, 3854, 7, 71, 2, 2, 3854, 752, 3, 2, 2, 2, 3855, 3856, 7, 89, 2, 2, 3856, 3857, 7, 75, 2, 2, 3857, 3858, 7, 86, 2, 2, 3858, 3859, 7, 74, 2, 2, 3859, 3860, 7, 81, 2, 2, 3860, 3861, 7, 87, 2, 2, 3861, 3862, 7, 86, 2, 2, 3862, 754, 3, 2, 2, 2, 3863, 3864, 7, 89, 2, 2, 3864, 3865, 7, 81, 2, 2, 3865, 3866, 7, 84, 2, 2, 3866, 3867, 7, 77, 2, 2, 3867, 756, 3, 2, 2, 2, 3868, 3869, 7, 89, 2, 2, 3869, 3870, 7, 84, 2, 2, 3870, 3871, 7, 67, 2, 2, 3871, 3872, 7, 82, 2, 2, 3872, 3873, 7, 82, 2, 2, 3873, 3874, 7, 71, 2, 2, 3874, 3875, 7, 84, 2, 2, 3875, 758, 3, 2, 2, 2, 3876, 3877, 7, 89, 2, 2, 3877, 3878, 7, 84, 2, 2, 3878, 3879, 7, 75, 2, 2, 3879, 3880, 7, 86, 2, 2, 3880, 3881, 7, 71, 2, 2, 3881, 760, 3, 2, 2, 2, 3882, 3883, 7, 90, 2, 2, 3883, 3884, 7, 79, 2, 2, 3884, 3885, 7, 78, 2, 2, 3885, 762, 3, 2, 2, 2, 3886, 3887, 7, 91, 2, 2, 3887, 3888, 7, 71, 2, 2, 3888, 3889, 7, 67, 2, 2, 3889, 3890, 7, 84, 2, 2, 3890, 764, 3, 2, 2, 2, 3891, 3892, 7, 91, 2, 2, 3892, 3893, 7, 71, 2, 2, 3893, 3894, 7, 85, 2, 2, 3894, 766, 3, 2, 2, 2, 3895, 3896, 7, 92, 2, 2, 3896, 3897, 7, 81, 2, 2, 3897, 3898, 7, 80, 2, 2, 3898, 3899, 7, 71, 2, 2, 3899, 768, 3, 2, 2, 2, 3900, 3901, 7, 68, 2, 2, 3901, 3902, 7, 71, 2, 2, 3902, 3903, 7, 86, 2, 2, 3903, 3904, 7, 89, 2, 2, 3904, 3905, 7, 71, 2, 2, 3905, 3906, 7, 71, 2, 2, 3906, 3907, 7, 80, 2, 2, 3907, 770, 3, 2, 2, 2, 3908, 3909, 7, 68, 2, 2, 3909, 3910, 7, 75, 2, 2, 3910, 3911, 7, 73, 2, 2, 3911, 3912, 7, 75, 2, 2, 3912, 3913, 7, 80, 2, 2, 3913, 3914, 7, 86, 2, 2, 3914, 772, 3, 2, 2, 2, 3915, 3916, 7, 68, 2, 2, 3916, 3917, 7, 75, 2, 2, 3917, 3918, 7, 86, 2, 2, 3918, 774, 3, 2, 2, 2, 3919, 3920, 7, 68, 2, 2, 3920, 3921, 7, 81, 2, 2, 3921, 3922, 7, 81, 2, 2, 3922, 3923, 7, 78, 2, 2, 3923, 3924, 7, 71, 2, 2, 3924, 3925, 7, 67, 2, 2, 3925, 3926, 7, 80, 2, 2, 3926, 776, 3, 2, 2, 2, 3927, 3928, 7, 69, 2, 2, 3928, 3929, 7, 74, 2, 2, 3929, 3930, 7, 67, 2, 2, 3930, 3931, 7, 84, 2, 2, 3931, 778, 3, 2, 2, 2, 3932, 3933, 7, 69, 2, 2, 3933, 3934, 7, 74, 2, 2, 3934, 3935, 7, 67, 2, 2, 3935, 3936, 7, 84, 2, 2, 3936, 3937, 7, 67, 2, 2, 3937, 3938, 7, 69, 2, 2, 3938, 3939, 7, 86, 2, 2, 3939, 3940, 7, 71, 2, 2, 3940, 3941, 7, 84, 2, 2, 3941, 780, 3, 2, 2, 2, 3942, 3943, 7, 69, 2, 2, 3943, 3944, 7, 81, 2, 2, 3944, 3945, 7, 67, 2, 2, 3945, 3946, 7, 78, 2, 2, 3946, 3947, 7, 71, 2, 2, 3947, 3948, 7, 85, 2, 2, 3948, 3949, 7, 69, 2, 2, 3949, 3950, 7, 71, 2, 2, 3950, 782, 3, 2, 2, 2, 3951, 3952, 7, 70, 2, 2, 3952, 3953, 7, 71, 2, 2, 3953, 3954, 7, 69, 2, 2, 3954, 784, 3, 2, 2, 2, 3955, 3956, 7, 70, 2, 2, 3956, 3957, 7, 71, 2, 2, 3957, 3958, 7, 69, 2, 2, 3958, 3959, 7, 75, 2, 2, 3959, 3960, 7, 79, 2, 2, 3960, 3961, 7, 67, 2, 2, 3961, 3962, 7, 78, 2, 2, 3962, 786, 3, 2, 2, 2, 3963, 3964, 7, 71, 2, 2, 3964, 3965, 7, 90, 2, 2, 3965, 3966, 7, 75, 2, 2, 3966, 3967, 7, 85, 2, 2, 3967, 3968, 7, 86, 2, 2, 3968, 3969, 7, 85, 2, 2, 3969, 788, 3, 2, 2, 2, 3970, 3971, 7, 71, 2, 2, 3971, 3972, 7, 90, 2, 2, 3972, 3973, 7, 86, 2, 2, 3973, 3974, 7, 84, 2, 2, 3974, 3975, 7, 67, 2, 2, 3975, 3976, 7, 69, 2, 2, 3976, 3977, 7, 86, 2, 2, 3977, 790, 3, 2, 2, 2, 3978, 3979, 7, 72, 2, 2, 3979, 3980, 7, 78, 2, 2, 3980, 3981, 7, 81, 2, 2, 3981, 3982, 7, 67, 2, 2, 3982, 3983, 7, 86, 2, 2, 3983, 792, 3, 2, 2, 2, 3984, 3985, 7, 73, 2, 2, 3985, 3986, 7, 84, 2, 2, 3986, 3987, 7, 71, 2, 2, 3987, 3988, 7, 67, 2, 2, 3988, 3989, 7, 86, 2, 2, 3989, 3990, 7, 71, 2, 2, 3990, 3991, 7, 85, 2, 2, 3991, 3992, 7, 86, 2, 2, 3992, 794, 3, 2, 2, 2, 3993, 3994, 7, 75, 2, 2, 3994, 3995, 7, 80, 2, 2, 3995, 3996, 7, 81, 2, 2, 3996, 3997, 7, 87, 2, 2, 3997, 3998, 7, 86, 2, 2, 3998, 796, 3, 2, 2, 2, 3999, 4000, 7, 75, 2, 2, 4000, 4001, 7, 80, 2, 2, 4001, 4002, 7, 86, 2, 2, 4002, 798, 3, 2, 2, 2, 4003, 4004, 7, 75, 2, 2, 4004, 4005, 7, 80, 2, 2, 4005, 4006, 7, 86, 2, 2, 4006, 4007, 7, 71, 2, 2, 4007, 4008, 7, 73, 2, 2, 4008, 4009, 7, 71, 2, 2, 4009, 4010, 7, 84, 2, 2, 4010, 800, 3, 2, 2, 2, 4011, 4012, 7, 75, 2, 2, 4012, 4013, 7, 80, 2, 2, 4013, 4014, 7, 86, 2, 2, 4014, 4015, 7, 71, 2, 2, 4015, 4016, 7, 84, 2, 2, 4016, 4017, 7, 88, 2, 2, 4017, 4018, 7, 67, 2, 2, 4018, 4019, 7, 78, 2, 2, 4019, 802, 3, 2, 2, 2, 4020, 4021, 7, 78, 2, 2, 4021, 4022, 7, 71, 2, 2, 4022, 4023, 7, 67, 2, 2, 4023, 4024, 7, 85, 2, 2, 4024, 4025, 7, 86, 2, 2, 4025, 804, 3, 2, 2, 2, 4026, 4027, 7, 80, 2, 2, 4027, 4028, 7, 67, 2, 2, 4028, 4029, 7, 86, 2, 2, 4029, 4030, 7, 75, 2, 2, 4030, 4031, 7, 81, 2, 2, 4031, 4032, 7, 80, 2, 2, 4032, 4033, 7, 67, 2, 2, 4033, 4034, 7, 78, 2, 2, 4034, 806, 3, 2, 2, 2, 4035, 4036, 7, 80, 2, 2, 4036, 4037, 7, 69, 2, 2, 4037, 4038, 7, 74, 2, 2, 4038, 4039, 7, 67, 2, 2, 4039, 4040, 7, 84, 2, 2, 4040, 808, 3, 2, 2, 2, 4041, 4042, 7, 80, 2, 2, 4042, 4043, 7, 81, 2, 2, 4043, 4044, 7, 80, 2, 2, 4044, 4045, 7, 71, 2, 2, 4045, 810, 3, 2, 2, 2, 4046, 4047, 7, 80, 2, 2, 4047, 4048, 7, 87, 2, 2, 4048, 4049, 7, 78, 2, 2, 4049, 4050, 7, 78, 2, 2, 4050, 4051, 7, 75, 2, 2, 4051, 4052, 7, 72, 2, 2, 4052, 812, 3, 2, 2, 2, 4053, 4054, 7, 80, 2, 2, 4054, 4055, 7, 87, 2, 2, 4055, 4056, 7, 79, 2, 2, 4056, 4057, 7, 71, 2, 2, 4057, 4058, 7, 84, 2, 2, 4058, 4059, 7, 75, 2, 2, 4059, 4060, 7, 69, 2, 2, 4060, 814, 3, 2, 2, 2, 4061, 4062, 7, 81, 2, 2, 4062, 4063, 7, 88, 2, 2, 4063, 4064, 7, 71, 2, 2, 4064, 4065, 7, 84, 2, 2, 4065, 4066, 7, 78, 2, 2, 4066, 4067, 7, 67, 2, 2, 4067, 4068, 7, 91, 2, 2, 4068, 816, 3, 2, 2, 2, 4069, 4070, 7, 82, 2, 2, 4070, 4071, 7, 81, 2, 2, 4071, 4072, 7, 85, 2, 2, 4072, 4073, 7, 75, 2, 2, 4073, 4074, 7, 86, 2, 2, 4074, 4075, 7, 75, 2, 2, 4075, 4076, 7, 81, 2, 2, 4076, 4077, 7, 80, 2, 2, 4077, 818, 3, 2, 2, 2, 4078, 4079, 7, 82, 2, 2, 4079, 4080, 7, 84, 2, 2, 4080, 4081, 7, 71, 2, 2, 4081, 4082, 7, 69, 2, 2, 4082, 4083, 7, 75, 2, 2, 4083, 4084, 7, 85, 2, 2, 4084, 4085, 7, 75, 2, 2, 4085, 4086, 7, 81, 2, 2, 4086, 4087, 7, 80, 2, 2, 4087, 820, 3, 2, 2, 2, 4088, 4089, 7, 84, 2, 2, 4089, 4090, 7, 71, 2, 2, 4090, 4091, 7, 67, 2, 2, 4091, 4092, 7, 78, 2, 2, 4092, 822, 3, 2, 2, 2, 4093, 4094, 7, 84, 2, 2, 4094, 4095, 7, 81, 2, 2, 4095, 4096, 7, 89, 2, 2, 4096, 824, 3, 2, 2, 2, 4097, 4098, 7, 85, 2, 2, 4098, 4099, 7, 71, 2, 2, 4099, 4100, 7, 86, 2, 2, 4100, 4101, 7, 81, 2, 2, 4101, 4102, 7, 72, 2, 2, 4102, 826, 3, 2, 2, 2, 4103, 4104, 7, 85, 2, 2, 4104, 4105, 7, 79, 2, 2, 4105, 4106, 7, 67, 2, 2, 4106, 4107, 7, 78, 2, 2, 4107, 4108, 7, 78, 2, 2, 4108, 4109, 7, 75, 2, 2, 4109, 4110, 7, 80, 2, 2, 4110, 4111, 7, 86, 2, 2, 4111, 828, 3, 2, 2, 2, 4112, 4113, 7, 85, 2, 2, 4113, 4114, 7, 87, 2, 2, 4114, 4115, 7, 68, 2, 2, 4115, 4116, 7, 85, 2, 2, 4116, 4117, 7, 86, 2, 2, 4117, 4118, 7, 84, 2, 2, 4118, 4119, 7, 75, 2, 2, 4119, 4120, 7, 80, 2, 2, 4120, 4121, 7, 73, 2, 2, 4121, 830, 3, 2, 2, 2, 4122, 4123, 7, 86, 2, 2, 4123, 4124, 7, 75, 2, 2, 4124, 4125, 7, 79, 2, 2, 4125, 4126, 7, 71, 2, 2, 4126, 832, 3, 2, 2, 2, 4127, 4128, 7, 86, 2, 2, 4128, 4129, 7, 75, 2, 2, 4129, 4130, 7, 79, 2, 2, 4130, 4131, 7, 71, 2, 2, 4131, 4132, 7, 85, 2, 2, 4132, 4133, 7, 86, 2, 2, 4133, 4134, 7, 67, 2, 2, 4134, 4135, 7, 79, 2, 2, 4135, 4136, 7, 82, 2, 2, 4136, 834, 3, 2, 2, 2, 4137, 4138, 7, 86, 2, 2, 4138, 4139, 7, 84, 2, 2, 4139, 4140, 7, 71, 2, 2, 4140, 4141, 7, 67, 2, 2, 4141, 4142, 7, 86, 2, 2, 4142, 836, 3, 2, 2, 2, 4143, 4144, 7, 86, 2, 2, 4144, 4145, 7, 84, 2, 2, 4145, 4146, 7, 75, 2, 2, 4146, 4147, 7, 79, 2, 2, 4147, 838, 3, 2, 2, 2, 4148, 4149, 7, 88, 2, 2, 4149, 4150, 7, 67, 2, 2, 4150, 4151, 7, 78, 2, 2, 4151, 4152, 7, 87, 2, 2, 4152, 4153, 7, 71, 2, 2, 4153, 4154, 7, 85, 2, 2, 4154, 840, 3, 2, 2, 2, 4155, 4156, 7, 88, 2, 2, 4156, 4157, 7, 67, 2, 2, 4157, 4158, 7, 84, 2, 2, 4158, 4159, 7, 69, 2, 2, 4159, 4160, 7, 74, 2, 2, 4160, 4161, 7, 67, 2, 2, 4161, 4162, 7, 84, 2, 2, 4162, 842, 3, 2, 2, 2, 4163, 4164, 7, 90, 2, 2, 4164, 4165, 7, 79, 2, 2, 4165, 4166, 7, 78, 2, 2, 4166, 4167, 7, 67, 2, 2, 4167, 4168, 7, 86, 2, 2, 4168, 4169, 7, 86, 2, 2, 4169, 4170, 7, 84, 2, 2, 4170, 4171, 7, 75, 2, 2, 4171, 4172, 7, 68, 2, 2, 4172, 4173, 7, 87, 2, 2, 4173, 4174, 7, 86, 2, 2, 4174, 4175, 7, 71, 2, 2, 4175, 4176, 7, 85, 2, 2, 4176, 844, 3, 2, 2, 2, 4177, 4178, 7, 90, 2, 2, 4178, 4179, 7, 79, 2, 2, 4179, 4180, 7, 78, 2, 2, 4180, 4181, 7, 69, 2, 2, 4181, 4182, 7, 81, 2, 2, 4182, 4183, 7, 80, 2, 2, 4183, 4184, 7, 69, 2, 2, 4184, 4185, 7, 67, 2, 2, 4185, 4186, 7, 86, 2, 2, 4186, 846, 3, 2, 2, 2, 4187, 4188, 7, 90, 2, 2, 4188, 4189, 7, 79, 2, 2, 4189, 4190, 7, 78, 2, 2, 4190, 4191, 7, 71, 2, 2, 4191, 4192, 7, 78, 2, 2, 4192, 4193, 7, 71, 2, 2, 4193, 4194, 7, 79, 2, 2, 4194, 4195, 7, 71, 2, 2, 4195, 4196, 7, 80, 2, 2, 4196, 4197, 7, 86, 2, 2, 4197, 848, 3, 2, 2, 2, 4198, 4199, 7, 90, 2, 2, 4199, 4200, 7, 79, 2, 2, 4200, 4201, 7, 78, 2, 2, 4201, 4202, 7, 71, 2, 2, 4202, 4203, 7, 90, 2, 2, 4203, 4204, 7, 75, 2, 2, 4204, 4205, 7, 85, 2, 2, 4205, 4206, 7, 86, 2, 2, 4206, 4207, 7, 85, 2, 2, 4207, 850, 3, 2, 2, 2, 4208, 4209, 7, 90, 2, 2, 4209, 4210, 7, 79, 2, 2, 4210, 4211, 7, 78, 2, 2, 4211, 4212, 7, 72, 2, 2, 4212, 4213, 7, 81, 2, 2, 4213, 4214, 7, 84, 2, 2, 4214, 4215, 7, 71, 2, 2, 4215, 4216, 7, 85, 2, 2, 4216, 4217, 7, 86, 2, 2, 4217, 852, 3, 2, 2, 2, 4218, 4219, 7, 90, 2, 2, 4219, 4220, 7, 79, 2, 2, 4220, 4221, 7, 78, 2, 2, 4221, 4222, 7, 82, 2, 2, 4222, 4223, 7, 67, 2, 2, 4223, 4224, 7, 84, 2, 2, 4224, 4225, 7, 85, 2, 2, 4225, 4226, 7, 71, 2, 2, 4226, 854, 3, 2, 2, 2, 4227, 4228, 7, 90, 2, 2, 4228, 4229, 7, 79, 2, 2, 4229, 4230, 7, 78, 2, 2, 4230, 4231, 7, 82, 2, 2, 4231, 4232, 7, 75, 2, 2, 4232, 856, 3, 2, 2, 2, 4233, 4234, 7, 90, 2, 2, 4234, 4235, 7, 79, 2, 2, 4235, 4236, 7, 78, 2, 2, 4236, 4237, 7, 84, 2, 2, 4237, 4238, 7, 81, 2, 2, 4238, 4239, 7, 81, 2, 2, 4239, 4240, 7, 86, 2, 2, 4240, 858, 3, 2, 2, 2, 4241, 4242, 7, 90, 2, 2, 4242, 4243, 7, 79, 2, 2, 4243, 4244, 7, 78, 2, 2, 4244, 4245, 7, 85, 2, 2, 4245, 4246, 7, 71, 2, 2, 4246, 4247, 7, 84, 2, 2, 4247, 4248, 7, 75, 2, 2, 4248, 4249, 7, 67, 2, 2, 4249, 4250, 7, 78, 2, 2, 4250, 4251, 7, 75, 2, 2, 4251, 4252, 7, 92, 2, 2, 4252, 4253, 7, 71, 2, 2, 4253, 860, 3, 2, 2, 2, 4254, 4255, 7, 69, 2, 2, 4255, 4256, 7, 67, 2, 2, 4256, 4257, 7, 78, 2, 2, 4257, 4258, 7, 78, 2, 2, 4258, 862, 3, 2, 2, 2, 4259, 4260, 7, 69, 2, 2, 4260, 4261, 7, 87, 2, 2, 4261, 4262, 7, 84, 2, 2, 4262, 4263, 7, 84, 2, 2, 4263, 4264, 7, 71, 2, 2, 4264, 4265, 7, 80, 2, 2, 4265, 4266, 7, 86, 2, 2, 4266, 864, 3, 2, 2, 2, 4267, 4268, 7, 67, 2, 2, 4268, 4269, 7, 86, 2, 2, 4269, 4270, 7, 86, 2, 2, 4270, 4271, 7, 67, 2, 2, 4271, 4272, 7, 69, 2, 2, 4272, 4273, 7, 74, 2, 2, 4273, 866, 3, 2, 2, 2, 4274, 4275, 7, 70, 2, 2, 4275, 4276, 7, 71, 2, 2, 4276, 4277, 7, 86, 2, 2, 4277, 4278, 7, 67, 2, 2, 4278, 4279, 7, 69, 2, 2, 4279, 4280, 7, 74, 2, 2, 4280, 868, 3, 2, 2, 2, 4281, 4282, 7, 71, 2, 2, 4282, 4283, 7, 90, 2, 2, 4283, 4284, 7, 82, 2, 2, 4284, 4285, 7, 84, 2, 2, 4285, 4286, 7, 71, 2, 2, 4286, 4287, 7, 85, 2, 2, 4287, 4288, 7, 85, 2, 2, 4288, 4289, 7, 75, 2, 2, 4289, 4290, 7, 81, 2, 2, 4290, 4291, 7, 80, 2, 2, 4291, 870, 3, 2, 2, 2, 4292, 4293, 7, 73, 2, 2, 4293, 4294, 7, 71, 2, 2, 4294, 4295, 7, 80, 2, 2, 4295, 4296, 7, 71, 2, 2, 4296, 4297, 7, 84, 2, 2, 4297, 4298, 7, 67, 2, 2, 4298, 4299, 7, 86, 2, 2, 4299, 4300, 7, 71, 2, 2, 4300, 4301, 7, 70, 2, 2, 4301, 872, 3, 2, 2, 2, 4302, 4303, 7, 78, 2, 2, 4303, 4304, 7, 81, 2, 2, 4304, 4305, 7, 73, 2, 2, 4305, 4306, 7, 73, 2, 2, 4306, 4307, 7, 71, 2, 2, 4307, 4308, 7, 70, 2, 2, 4308, 874, 3, 2, 2, 2, 4309, 4310, 7, 85, 2, 2, 4310, 4311, 7, 86, 2, 2, 4311, 4312, 7, 81, 2, 2, 4312, 4313, 7, 84, 2, 2, 4313, 4314, 7, 71, 2, 2, 4314, 4315, 7, 70, 2, 2, 4315, 876, 3, 2, 2, 2, 4316, 4317, 7, 75, 2, 2, 4317, 4318, 7, 80, 2, 2, 4318, 4319, 7, 69, 2, 2, 4319, 4320, 7, 78, 2, 2, 4320, 4321, 7, 87, 2, 2, 4321, 4322, 7, 70, 2, 2, 4322, 4323, 7, 71, 2, 2, 4323, 878, 3, 2, 2, 2, 4324, 4325, 7, 84, 2, 2, 4325, 4326, 7, 81, 2, 2, 4326, 4327, 7, 87, 2, 2, 4327, 4328, 7, 86, 2, 2, 4328, 4329, 7, 75, 2, 2, 4329, 4330, 7, 80, 2, 2, 4330, 4331, 7, 71, 2, 2, 4331, 880, 3, 2, 2, 2, 4332, 4333, 7, 86, 2, 2, 4333, 4334, 7, 84, 2, 2, 4334, 4335, 7, 67, 2, 2, 4335, 4336, 7, 80, 2, 2, 4336, 4337, 7, 85, 2, 2, 4337, 4338, 7, 72, 2, 2, 4338, 4339, 7, 81, 2, 2, 4339, 4340, 7, 84, 2, 2, 4340, 4341, 7, 79, 2, 2, 4341, 882, 3, 2, 2, 2, 4342, 4343, 7, 75, 2, 2, 4343, 4344, 7, 79, 2, 2, 4344, 4345, 7, 82, 2, 2, 4345, 4346, 7, 81, 2, 2, 4346, 4347, 7, 84, 2, 2, 4347, 4348, 7, 86, 2, 2, 4348, 884, 3, 2, 2, 2, 4349, 4350, 7, 82, 2, 2, 4350, 4351, 7, 81, 2, 2, 4351, 4352, 7, 78, 2, 2, 4352, 4353, 7, 75, 2, 2, 4353, 4354, 7, 69, 2, 2, 4354, 4355, 7, 91, 2, 2, 4355, 886, 3, 2, 2, 2, 4356, 4357, 7, 79, 2, 2, 4357, 4358, 7, 71, 2, 2, 4358, 4359, 7, 86, 2, 2, 4359, 4360, 7, 74, 2, 2, 4360, 4361, 7, 81, 2, 2, 4361, 4362, 7, 70, 2, 2, 4362, 888, 3, 2, 2, 2, 4363, 4364, 7, 84, 2, 2, 4364, 4365, 7, 71, 2, 2, 4365, 4366, 7, 72, 2, 2, 4366, 4367, 7, 71, 2, 2, 4367, 4368, 7, 84, 2, 2, 4368, 4369, 7, 71, 2, 2, 4369, 4370, 7, 80, 2, 2, 4370, 4371, 7, 69, 2, 2, 4371, 4372, 7, 75, 2, 2, 4372, 4373, 7, 80, 2, 2, 4373, 4374, 7, 73, 2, 2, 4374, 890, 3, 2, 2, 2, 4375, 4376, 7, 80, 2, 2, 4376, 4377, 7, 71, 2, 2, 4377, 4378, 7, 89, 2, 2, 4378, 892, 3, 2, 2, 2, 4379, 4380, 7, 81, 2, 2, 4380, 4381, 7, 78, 2, 2, 4381, 4382, 7, 70, 2, 2, 4382, 894, 3, 2, 2, 2, 4383, 4384, 7, 88, 2, 2, 4384, 4385, 7, 67, 2, 2, 4385, 4386, 7, 78, 2, 2, 4386, 4387, 7, 87, 2, 2, 4387, 4388, 7, 71, 2, 2, 4388, 896, 3, 2, 2, 2, 4389, 4390, 7, 85, 2, 2, 4390, 4391, 7, 87, 2, 2, 4391, 4392, 7, 68, 2, 2, 4392, 4393, 7, 85, 2, 2, 4393, 4394, 7, 69, 2, 2, 4394, 4395, 7, 84, 2, 2, 4395, 4396, 7, 75, 2, 2, 4396, 4397, 7, 82, 2, 2, 4397, 4398, 7, 86, 2, 2, 4398, 4399, 7, 75, 2, 2, 4399, 4400, 7, 81, 2, 2, 4400, 4401, 7, 80, 2, 2, 4401, 898, 3, 2, 2, 2, 4402, 4403, 7, 82, 2, 2, 4403, 4404, 7, 87, 2, 2, 4404, 4405, 7, 68, 2, 2, 4405, 4406, 7, 78, 2, 2, 4406, 4407, 7, 75, 2, 2, 4407, 4408, 7, 69, 2, 2, 4408, 4409, 7, 67, 2, 2, 4409, 4410, 7, 86, 2, 2, 4410, 4411, 7, 75, 2, 2, 4411, 4412, 7, 81, 2, 2, 4412, 4413, 7, 80, 2, 2, 4413, 900, 3, 2, 2, 2, 4414, 4415, 7, 81, 2, 2, 4415, 4416, 7, 87, 2, 2, 4416, 4417, 7, 86, 2, 2, 4417, 902, 3, 2, 2, 2, 4418, 4419, 7, 71, 2, 2, 4419, 4420, 7, 80, 2, 2, 4420, 4421, 7, 70, 2, 2, 4421, 904, 3, 2, 2, 2, 4422, 4423, 7, 84, 2, 2, 4423, 4424, 7, 81, 2, 2, 4424, 4425, 7, 87, 2, 2, 4425, 4426, 7, 86, 2, 2, 4426, 4427, 7, 75, 2, 2, 4427, 4428, 7, 80, 2, 2, 4428, 4429, 7, 71, 2, 2, 4429, 4430, 7, 85, 2, 2, 4430, 906, 3, 2, 2, 2, 4431, 4432, 7, 85, 2, 2, 4432, 4433, 7, 69, 2, 2, 4433, 4434, 7, 74, 2, 2, 4434, 4435, 7, 71, 2, 2, 4435, 4436, 7, 79, 2, 2, 4436, 4437, 7, 67, 2, 2, 4437, 4438, 7, 85, 2, 2, 4438, 908, 3, 2, 2, 2, 4439, 4440, 7, 82, 2, 2, 4440, 4441, 7, 84, 2, 2, 4441, 4442, 7, 81, 2, 2, 4442, 4443, 7, 69, 2, 2, 4443, 4444, 7, 71, 2, 2, 4444, 4445, 7, 70, 2, 2, 4445, 4446, 7, 87, 2, 2, 4446, 4447, 7, 84, 2, 2, 4447, 4448, 7, 71, 2, 2, 4448, 4449, 7, 85, 2, 2, 4449, 910, 3, 2, 2, 2, 4450, 4451, 7, 75, 2, 2, 4451, 4452, 7, 80, 2, 2, 4452, 4453, 7, 82, 2, 2, 4453, 4454, 7, 87, 2, 2, 4454, 4455, 7, 86, 2, 2, 4455, 912, 3, 2, 2, 2, 4456, 4457, 7, 85, 2, 2, 4457, 4458, 7, 87, 2, 2, 4458, 4459, 7, 82, 2, 2, 4459, 4460, 7, 82, 2, 2, 4460, 4461, 7, 81, 2, 2, 4461, 4462, 7, 84, 2, 2, 4462, 4463, 7, 86, 2, 2, 4463, 914, 3, 2, 2, 2, 4464, 4465, 7, 82, 2, 2, 4465, 4466, 7, 67, 2, 2, 4466, 4467, 7, 84, 2, 2, 4467, 4468, 7, 67, 2, 2, 4468, 4469, 7, 78, 2, 2, 4469, 4470, 7, 78, 2, 2, 4470, 4471, 7, 71, 2, 2, 4471, 4472, 7, 78, 2, 2, 4472, 916, 3, 2, 2, 2, 4473, 4474, 7, 85, 2, 2, 4474, 4475, 7, 83, 2, 2, 4475, 4476, 7, 78, 2, 2, 4476, 918, 3, 2, 2, 2, 4477, 4478, 7, 70, 2, 2, 4478, 4479, 7, 71, 2, 2, 4479, 4480, 7, 82, 2, 2, 4480, 4481, 7, 71, 2, 2, 4481, 4482, 7, 80, 2, 2, 4482, 4483, 7, 70, 2, 2, 4483, 4484, 7, 85, 2, 2, 4484, 920, 3, 2, 2, 2, 4485, 4486, 7, 81, 2, 2, 4486, 4487, 7, 88, 2, 2, 4487, 4488, 7, 71, 2, 2, 4488, 4489, 7, 84, 2, 2, 4489, 4490, 7, 84, 2, 2, 4490, 4491, 7, 75, 2, 2, 4491, 4492, 7, 70, 2, 2, 4492, 4493, 7, 75, 2, 2, 4493, 4494, 7, 80, 2, 2, 4494, 4495, 7, 73, 2, 2, 4495, 922, 3, 2, 2, 2, 4496, 4497, 7, 69, 2, 2, 4497, 4498, 7, 81, 2, 2, 4498, 4499, 7, 80, 2, 2, 4499, 4500, 7, 72, 2, 2, 4500, 4501, 7, 78, 2, 2, 4501, 4502, 7, 75, 2, 2, 4502, 4503, 7, 69, 2, 2, 4503, 4504, 7, 86, 2, 2, 4504, 924, 3, 2, 2, 2, 4505, 4506, 7, 85, 2, 2, 4506, 4507, 7, 77, 2, 2, 4507, 4508, 7, 75, 2, 2, 4508, 4509, 7, 82, 2, 2, 4509, 926, 3, 2, 2, 2, 4510, 4511, 7, 78, 2, 2, 4511, 4512, 7, 81, 2, 2, 4512, 4513, 7, 69, 2, 2, 4513, 4514, 7, 77, 2, 2, 4514, 4515, 7, 71, 2, 2, 4515, 4516, 7, 70, 2, 2, 4516, 928, 3, 2, 2, 2, 4517, 4518, 7, 86, 2, 2, 4518, 4519, 7, 75, 2, 2, 4519, 4520, 7, 71, 2, 2, 4520, 4521, 7, 85, 2, 2, 4521, 930, 3, 2, 2, 2, 4522, 4523, 7, 84, 2, 2, 4523, 4524, 7, 81, 2, 2, 4524, 4525, 7, 78, 2, 2, 4525, 4526, 7, 78, 2, 2, 4526, 4527, 7, 87, 2, 2, 4527, 4528, 7, 82, 2, 2, 4528, 932, 3, 2, 2, 2, 4529, 4530, 7, 69, 2, 2, 4530, 4531, 7, 87, 2, 2, 4531, 4532, 7, 68, 2, 2, 4532, 4533, 7, 71, 2, 2, 4533, 934, 3, 2, 2, 2, 4534, 4535, 7, 73, 2, 2, 4535, 4536, 7, 84, 2, 2, 4536, 4537, 7, 81, 2, 2, 4537, 4538, 7, 87, 2, 2, 4538, 4539, 7, 82, 2, 2, 4539, 4540, 7, 75, 2, 2, 4540, 4541, 7, 80, 2, 2, 4541, 4542, 7, 73, 2, 2, 4542, 936, 3, 2, 2, 2, 4543, 4544, 7, 85, 2, 2, 4544, 4545, 7, 71, 2, 2, 4545, 4546, 7, 86, 2, 2, 4546, 4547, 7, 85, 2, 2, 4547, 938, 3, 2, 2, 2, 4548, 4549, 7, 86, 2, 2, 4549, 4550, 7, 67, 2, 2, 4550, 4551, 7, 68, 2, 2, 4551, 4552, 7, 78, 2, 2, 4552, 4553, 7, 71, 2, 2, 4553, 4554, 7, 85, 2, 2, 4554, 4555, 7, 67, 2, 2, 4555, 4556, 7, 79, 2, 2, 4556, 4557, 7, 82, 2, 2, 4557, 4558, 7, 78, 2, 2, 4558, 4559, 7, 71, 2, 2, 4559, 940, 3, 2, 2, 2, 4560, 4561, 7, 81, 2, 2, 4561, 4562, 7, 84, 2, 2, 4562, 4563, 7, 70, 2, 2, 4563, 4564, 7, 75, 2, 2, 4564, 4565, 7, 80, 2, 2, 4565, 4566, 7, 67, 2, 2, 4566, 4567, 7, 78, 2, 2, 4567, 4568, 7, 75, 2, 2, 4568, 4569, 7, 86, 2, 2, 4569, 4570, 7, 91, 2, 2, 4570, 942, 3, 2, 2, 2, 4571, 4572, 7, 90, 2, 2, 4572, 4573, 7, 79, 2, 2, 4573, 4574, 7, 78, 2, 2, 4574, 4575, 7, 86, 2, 2, 4575, 4576, 7, 67, 2, 2, 4576, 4577, 7, 68, 2, 2, 4577, 4578, 7, 78, 2, 2, 4578, 4579, 7, 71, 2, 2, 4579, 944, 3, 2, 2, 2, 4580, 4581, 7, 69, 2, 2, 4581, 4582, 7, 81, 2, 2, 4582, 4583, 7, 78, 2, 2, 4583, 4584, 7, 87, 2, 2, 4584, 4585, 7, 79, 2, 2, 4585, 4586, 7, 80, 2, 2, 4586, 4587, 7, 85, 2, 2, 4587, 946, 3, 2, 2, 2, 4588, 4589, 7, 90, 2, 2, 4589, 4590, 7, 79, 2, 2, 4590, 4591, 7, 78, 2, 2, 4591, 4592, 7, 80, 2, 2, 4592, 4593, 7, 67, 2, 2, 4593, 4594, 7, 79, 2, 2, 4594, 4595, 7, 71, 2, 2, 4595, 4596, 7, 85, 2, 2, 4596, 4597, 7, 82, 2, 2, 4597, 4598, 7, 67, 2, 2, 4598, 4599, 7, 69, 2, 2, 4599, 4600, 7, 71, 2, 2, 4600, 4601, 7, 85, 2, 2, 4601, 948, 3, 2, 2, 2, 4602, 4603, 7, 84, 2, 2, 4603, 4604, 7, 81, 2, 2, 4604, 4605, 7, 89, 2, 2, 4605, 4606, 7, 86, 2, 2, 4606, 4607, 7, 91, 2, 2, 4607, 4608, 7, 82, 2, 2, 4608, 4609, 7, 71, 2, 2, 4609, 950, 3, 2, 2, 2, 4610, 4611, 7, 80, 2, 2, 4611, 4612, 7, 81, 2, 2, 4612, 4613, 7, 84, 2, 2, 4613, 4614, 7, 79, 2, 2, 4614, 4615, 7, 67, 2, 2, 4615, 4616, 7, 78, 2, 2, 4616, 4617, 7, 75, 2, 2, 4617, 4618, 7, 92, 2, 2, 4618, 4619, 7, 71, 2, 2, 4619, 4620, 7, 70, 2, 2, 4620, 952, 3, 2, 2, 2, 4621, 4622, 7, 89, 2, 2, 4622, 4623, 7, 75, 2, 2, 4623, 4624, 7, 86, 2, 2, 4624, 4625, 7, 74, 2, 2, 4625, 4626, 7, 75, 2, 2, 4626, 4627, 7, 80, 2, 2, 4627, 954, 3, 2, 2, 2, 4628, 4629, 7, 72, 2, 2, 4629, 4630, 7, 75, 2, 2, 4630, 4631, 7, 78, 2, 2, 4631, 4632, 7, 86, 2, 2, 4632, 4633, 7, 71, 2, 2, 4633, 4634, 7, 84, 2, 2, 4634, 956, 3, 2, 2, 2, 4635, 4636, 7, 73, 2, 2, 4636, 4637, 7, 84, 2, 2, 4637, 4638, 7, 81, 2, 2, 4638, 4639, 7, 87, 2, 2, 4639, 4640, 7, 82, 2, 2, 4640, 4641, 7, 85, 2, 2, 4641, 958, 3, 2, 2, 2, 4642, 4643, 7, 81, 2, 2, 4643, 4644, 7, 86, 2, 2, 4644, 4645, 7, 74, 2, 2, 4645, 4646, 7, 71, 2, 2, 4646, 4647, 7, 84, 2, 2, 4647, 4648, 7, 85, 2, 2, 4648, 960, 3, 2, 2, 2, 4649, 4650, 7, 80, 2, 2, 4650, 4651, 7, 72, 2, 2, 4651, 4652, 7, 69, 2, 2, 4652, 962, 3, 2, 2, 2, 4653, 4654, 7, 80, 2, 2, 4654, 4655, 7, 72, 2, 2, 4655, 4656, 7, 70, 2, 2, 4656, 964, 3, 2, 2, 2, 4657, 4658, 7, 80, 2, 2, 4658, 4659, 7, 72, 2, 2, 4659, 4660, 7, 77, 2, 2, 4660, 4661, 7, 69, 2, 2, 4661, 966, 3, 2, 2, 2, 4662, 4663, 7, 80, 2, 2, 4663, 4664, 7, 72, 2, 2, 4664, 4665, 7, 77, 2, 2, 4665, 4666, 7, 70, 2, 2, 4666, 968, 3, 2, 2, 2, 4667, 4668, 7, 87, 2, 2, 4668, 4669, 7, 71, 2, 2, 4669, 4670, 7, 85, 2, 2, 4670, 4671, 7, 69, 2, 2, 4671, 4672, 7, 67, 2, 2, 4672, 4673, 7, 82, 2, 2, 4673, 4674, 7, 71, 2, 2, 4674, 970, 3, 2, 2, 2, 4675, 4676, 7, 88, 2, 2, 4676, 4677, 7, 75, 2, 2, 4677, 4678, 7, 71, 2, 2, 4678, 4679, 7, 89, 2, 2, 4679, 4680, 7, 85, 2, 2, 4680, 972, 3, 2, 2, 2, 4681, 4682, 7, 80, 2, 2, 4682, 4683, 7, 81, 2, 2, 4683, 4684, 7, 84, 2, 2, 4684, 4685, 7, 79, 2, 2, 4685, 4686, 7, 67, 2, 2, 4686, 4687, 7, 78, 2, 2, 4687, 4688, 7, 75, 2, 2, 4688, 4689, 7, 92, 2, 2, 4689, 4690, 7, 71, 2, 2, 4690, 974, 3, 2, 2, 2, 4691, 4692, 7, 70, 2, 2, 4692, 4693, 7, 87, 2, 2, 4693, 4694, 7, 79, 2, 2, 4694, 4695, 7, 82, 2, 2, 4695, 976, 3, 2, 2, 2, 4696, 4697, 7, 82, 2, 2, 4697, 4698, 7, 84, 2, 2, 4698, 4699, 7, 75, 2, 2, 4699, 4700, 7, 80, 2, 2, 4700, 4701, 7, 86, 2, 2, 4701, 4702, 7, 97, 2, 2, 4702, 4703, 7, 85, 2, 2, 4703, 4704, 7, 86, 2, 2, 4704, 4705, 7, 84, 2, 2, 4705, 4706, 7, 75, 2, 2, 4706, 4707, 7, 69, 2, 2, 4707, 4708, 7, 86, 2, 2, 4708, 4709, 7, 97, 2, 2, 4709, 4710, 7, 82, 2, 2, 4710, 4711, 7, 67, 2, 2, 4711, 4712, 7, 84, 2, 2, 4712, 4713, 7, 67, 2, 2, 4713, 4714, 7, 79, 2, 2, 4714, 4715, 7, 85, 2, 2, 4715, 978, 3, 2, 2, 2, 4716, 4717, 7, 88, 2, 2, 4717, 4718, 7, 67, 2, 2, 4718, 4719, 7, 84, 2, 2, 4719, 4720, 7, 75, 2, 2, 4720, 4721, 7, 67, 2, 2, 4721, 4722, 7, 68, 2, 2, 4722, 4723, 7, 78, 2, 2, 4723, 4724, 7, 71, 2, 2, 4724, 4725, 7, 97, 2, 2, 4725, 4726, 7, 69, 2, 2, 4726, 4727, 7, 81, 2, 2, 4727, 4728, 7, 80, 2, 2, 4728, 4729, 7, 72, 2, 2, 4729, 4730, 7, 78, 2, 2, 4730, 4731, 7, 75, 2, 2, 4731, 4732, 7, 69, 2, 2, 4732, 4733, 7, 86, 2, 2, 4733, 980, 3, 2, 2, 2, 4734, 4735, 7, 71, 2, 2, 4735, 4736, 7, 84, 2, 2, 4736, 4737, 7, 84, 2, 2, 4737, 4738, 7, 81, 2, 2, 4738, 4739, 7, 84, 2, 2, 4739, 982, 3, 2, 2, 2, 4740, 4741, 7, 87, 2, 2, 4741, 4742, 7, 85, 2, 2, 4742, 4743, 7, 71, 2, 2, 4743, 4744, 7, 97, 2, 2, 4744, 4745, 7, 88, 2, 2, 4745, 4746, 7, 67, 2, 2, 4746, 4747, 7, 84, 2, 2, 4747, 4748, 7, 75, 2, 2, 4748, 4749, 7, 67, 2, 2, 4749, 4750, 7, 68, 2, 2, 4750, 4751, 7, 78, 2, 2, 4751, 4752, 7, 71, 2, 2, 4752, 984, 3, 2, 2, 2, 4753, 4754, 7, 87, 2, 2, 4754, 4755, 7, 85, 2, 2, 4755, 4756, 7, 71, 2, 2, 4756, 4757, 7, 97, 2, 2, 4757, 4758, 7, 69, 2, 2, 4758, 4759, 7, 81, 2, 2, 4759, 4760, 7, 78, 2, 2, 4760, 4761, 7, 87, 2, 2, 4761, 4762, 7, 79, 2, 2, 4762, 4763, 7, 80, 2, 2, 4763, 986, 3, 2, 2, 2, 4764, 4765, 7, 67, 2, 2, 4765, 4766, 7, 78, 2, 2, 4766, 4767, 7, 75, 2, 2, 4767, 4768, 7, 67, 2, 2, 4768, 4769, 7, 85, 2, 2, 4769, 988, 3, 2, 2, 2, 4770, 4771, 7, 69, 2, 2, 4771, 4772, 7, 81, 2, 2, 4772, 4773, 7, 80, 2, 2, 4773, 4774, 7, 85, 2, 2, 4774, 4775, 7, 86, 2, 2, 4775, 4776, 7, 67, 2, 2, 4776, 4777, 7, 80, 2, 2, 4777, 4778, 7, 86, 2, 2, 4778, 990, 3, 2, 2, 2, 4779, 4780, 7, 82, 2, 2, 4780, 4781, 7, 71, 2, 2, 4781, 4782, 7, 84, 2, 2, 4782, 4783, 7, 72, 2, 2, 4783, 4784, 7, 81, 2, 2, 4784, 4785, 7, 84, 2, 2, 4785, 4786, 7, 79, 2, 2, 4786, 992, 3, 2, 2, 2, 4787, 4788, 7, 73, 2, 2, 4788, 4789, 7, 71, 2, 2, 4789, 4790, 7, 86, 2, 2, 4790, 994, 3, 2, 2, 2, 4791, 4792, 7, 70, 2, 2, 4792, 4793, 7, 75, 2, 2, 4793, 4794, 7, 67, 2, 2, 4794, 4795, 7, 73, 2, 2, 4795, 4796, 7, 80, 2, 2, 4796, 4797, 7, 81, 2, 2, 4797, 4798, 7, 85, 2, 2, 4798, 4799, 7, 86, 2, 2, 4799, 4800, 7, 75, 2, 2, 4800, 4801, 7, 69, 2, 2, 4801, 4802, 7, 85, 2, 2, 4802, 996, 3, 2, 2, 2, 4803, 4804, 7, 85, 2, 2, 4804, 4805, 7, 86, 2, 2, 4805, 4806, 7, 67, 2, 2, 4806, 4807, 7, 69, 2, 2, 4807, 4808, 7, 77, 2, 2, 4808, 4809, 7, 71, 2, 2, 4809, 4810, 7, 70, 2, 2, 4810, 998, 3, 2, 2, 2, 4811, 4812, 7, 71, 2, 2, 4812, 4813, 7, 78, 2, 2, 4813, 4814, 7, 85, 2, 2, 4814, 4815, 7, 75, 2, 2, 4815, 4816, 7, 72, 2, 2, 4816, 1000, 3, 2, 2, 2, 4817, 4818, 7, 89, 2, 2, 4818, 4819, 7, 74, 2, 2, 4819, 4820, 7, 75, 2, 2, 4820, 4821, 7, 78, 2, 2, 4821, 4822, 7, 71, 2, 2, 4822, 1002, 3, 2, 2, 2, 4823, 4824, 7, 84, 2, 2, 4824, 4825, 7, 71, 2, 2, 4825, 4826, 7, 88, 2, 2, 4826, 4827, 7, 71, 2, 2, 4827, 4828, 7, 84, 2, 2, 4828, 4829, 7, 85, 2, 2, 4829, 4830, 7, 71, 2, 2, 4830, 1004, 3, 2, 2, 2, 4831, 4832, 7, 72, 2, 2, 4832, 4833, 7, 81, 2, 2, 4833, 4834, 7, 84, 2, 2, 4834, 4835, 7, 71, 2, 2, 4835, 4836, 7, 67, 2, 2, 4836, 4837, 7, 69, 2, 2, 4837, 4838, 7, 74, 2, 2, 4838, 1006, 3, 2, 2, 2, 4839, 4840, 7, 85, 2, 2, 4840, 4841, 7, 78, 2, 2, 4841, 4842, 7, 75, 2, 2, 4842, 4843, 7, 69, 2, 2, 4843, 4844, 7, 71, 2, 2, 4844, 1008, 3, 2, 2, 2, 4845, 4846, 7, 71, 2, 2, 4846, 4847, 7, 90, 2, 2, 4847, 4848, 7, 75, 2, 2, 4848, 4849, 7, 86, 2, 2, 4849, 1010, 3, 2, 2, 2, 4850, 4851, 7, 84, 2, 2, 4851, 4852, 7, 71, 2, 2, 4852, 4853, 7, 86, 2, 2, 4853, 4854, 7, 87, 2, 2, 4854, 4855, 7, 84, 2, 2, 4855, 4856, 7, 80, 2, 2, 4856, 1012, 3, 2, 2, 2, 4857, 4858, 7, 83, 2, 2, 4858, 4859, 7, 87, 2, 2, 4859, 4860, 7, 71, 2, 2, 4860, 4861, 7, 84, 2, 2, 4861, 4862, 7, 91, 2, 2, 4862, 1014, 3, 2, 2, 2, 4863, 4864, 7, 84, 2, 2, 4864, 4865, 7, 67, 2, 2, 4865, 4866, 7, 75, 2, 2, 4866, 4867, 7, 85, 2, 2, 4867, 4868, 7, 71, 2, 2, 4868, 1016, 3, 2, 2, 2, 4869, 4870, 7, 85, 2, 2, 4870, 4871, 7, 83, 2, 2, 4871, 4872, 7, 78, 2, 2, 4872, 4873, 7, 85, 2, 2, 4873, 4874, 7, 86, 2, 2, 4874, 4875, 7, 67, 2, 2, 4875, 4876, 7, 86, 2, 2, 4876, 4877, 7, 71, 2, 2, 4877, 1018, 3, 2, 2, 2, 4878, 4879, 7, 70, 2, 2, 4879, 4880, 7, 71, 2, 2, 4880, 4881, 7, 68, 2, 2, 4881, 4882, 7, 87, 2, 2, 4882, 4883, 7, 73, 2, 2, 4883, 1020, 3, 2, 2, 2, 4884, 4885, 7, 78, 2, 2, 4885, 4886, 7, 81, 2, 2, 4886, 4887, 7, 73, 2, 2, 4887, 1022, 3, 2, 2, 2, 4888, 4889, 7, 75, 2, 2, 4889, 4890, 7, 80, 2, 2, 4890, 4891, 7, 72, 2, 2, 4891, 4892, 7, 81, 2, 2, 4892, 1024, 3, 2, 2, 2, 4893, 4894, 7, 80, 2, 2, 4894, 4895, 7, 81, 2, 2, 4895, 4896, 7, 86, 2, 2, 4896, 4897, 7, 75, 2, 2, 4897, 4898, 7, 69, 2, 2, 4898, 4899, 7, 71, 2, 2, 4899, 1026, 3, 2, 2, 2, 4900, 4901, 7, 89, 2, 2, 4901, 4902, 7, 67, 2, 2, 4902, 4903, 7, 84, 2, 2, 4903, 4904, 7, 80, 2, 2, 4904, 4905, 7, 75, 2, 2, 4905, 4906, 7, 80, 2, 2, 4906, 4907, 7, 73, 2, 2, 4907, 1028, 3, 2, 2, 2, 4908, 4909, 7, 71, 2, 2, 4909, 4910, 7, 90, 2, 2, 4910, 4911, 7, 69, 2, 2, 4911, 4912, 7, 71, 2, 2, 4912, 4913, 7, 82, 2, 2, 4913, 4914, 7, 86, 2, 2, 4914, 4915, 7, 75, 2, 2, 4915, 4916, 7, 81, 2, 2, 4916, 4917, 7, 80, 2, 2, 4917, 1030, 3, 2, 2, 2, 4918, 4919, 7, 67, 2, 2, 4919, 4920, 7, 85, 2, 2, 4920, 4921, 7, 85, 2, 2, 4921, 4922, 7, 71, 2, 2, 4922, 4923, 7, 84, 2, 2, 4923, 4924, 7, 86, 2, 2, 4924, 1032, 3, 2, 2, 2, 4925, 4926, 7, 78, 2, 2, 4926, 4927, 7, 81, 2, 2, 4927, 4928, 7, 81, 2, 2, 4928, 4929, 7, 82, 2, 2, 4929, 1034, 3, 2, 2, 2, 4930, 4931, 7, 81, 2, 2, 4931, 4932, 7, 82, 2, 2, 4932, 4933, 7, 71, 2, 2, 4933, 4934, 7, 80, 2, 2, 4934, 1036, 3, 2, 2, 2, 4935, 4939, 5, 1039, 518, 2, 4936, 4938, 5, 1041, 519, 2, 4937, 4936, 3, 2, 2, 2, 4938, 4941, 3, 2, 2, 2, 4939, 4937, 3, 2, 2, 2, 4939, 4940, 3, 2, 2, 2, 4940, 1038, 3, 2, 2, 2, 4941, 4939, 3, 2, 2, 2, 4942, 4949, 9, 7, 2, 2, 4943, 4944, 9, 8, 2, 2, 4944, 4949, 6, 518, 8, 2, 4945, 4946, 9, 9, 2, 2, 4946, 4947, 9, 10, 2, 2, 4947, 4949, 6, 518, 9, 2, 4948, 4942, 3, 2, 2, 2, 4948, 4943, 3, 2, 2, 2, 4948, 4945, 3, 2, 2, 2, 4949, 1040, 3, 2, 2, 2, 4950, 4953, 5, 1043, 520, 2, 4951, 4953, 7, 38, 2, 2, 4952, 4950, 3, 2, 2, 2, 4952, 4951, 3, 2, 2, 2, 4953, 1042, 3, 2, 2, 2, 4954, 4957, 5, 1039, 518, 2, 4955, 4957, 9, 2, 2, 2, 4956, 4954, 3, 2, 2, 2, 4956, 4955, 3, 2, 2, 2, 4957, 1044, 3, 2, 2, 2, 4958, 4959, 5, 1047, 522, 2, 4959, 4960, 7, 36, 2, 2, 4960, 1046, 3, 2, 2, 2, 4961, 4967, 7, 36, 2, 2, 4962, 4963, 7, 36, 2, 2, 4963, 4966, 7, 36, 2, 2, 4964, 4966, 10, 11, 2, 2, 4965, 4962, 3, 2, 2, 2, 4965, 4964, 3, 2, 2, 2, 4966, 4969, 3, 2, 2, 2, 4967, 4965, 3, 2, 2, 2, 4967, 4968, 3, 2, 2, 2, 4968, 1048, 3, 2, 2, 2, 4969, 4967, 3, 2, 2, 2, 4970, 4971, 5, 1051, 524, 2, 4971, 4972, 7, 36, 2, 2, 4972, 1050, 3, 2, 2, 2, 4973, 4979, 7, 36, 2, 2, 4974, 4975, 7, 36, 2, 2, 4975, 4978, 7, 36, 2, 2, 4976, 4978, 10, 12, 2, 2, 4977, 4974, 3, 2, 2, 2, 4977, 4976, 3, 2, 2, 2, 4978, 4981, 3, 2, 2, 2, 4979, 4977, 3, 2, 2, 2, 4979, 4980, 3, 2, 2, 2, 4980, 1052, 3, 2, 2, 2, 4981, 4979, 3, 2, 2, 2, 4982, 4983, 7, 87, 2, 2, 4983, 4984, 7, 40, 2, 2, 4984, 4985, 5, 1045, 521, 2, 4985, 1054, 3, 2, 2, 2, 4986, 4987, 7, 87, 2, 2, 4987, 4988, 7, 40, 2, 2, 4988, 4989, 5, 1047, 522, 2, 4989, 1056, 3, 2, 2, 2, 4990, 4991, 7, 87, 2, 2, 4991, 4992, 7, 40, 2, 2, 4992, 4993, 5, 1049, 523, 2, 4993, 1058, 3, 2, 2, 2, 4994, 4995, 7, 87, 2, 2, 4995, 4996, 7, 40, 2, 2, 4996, 4997, 5, 1051, 524, 2, 4997, 1060, 3, 2, 2, 2, 4998, 4999, 5, 1063, 530, 2, 4999, 5000, 7, 41, 2, 2, 5000, 1062, 3, 2, 2, 2, 5001, 5007, 7, 41, 2, 2, 5002, 5003, 7, 41, 2, 2, 5003, 5006, 7, 41, 2, 2, 5004, 5006, 10, 13, 2, 2, 5005, 5002, 3, 2, 2, 2, 5005, 5004, 3, 2, 2, 2, 5006, 5009, 3, 2, 2, 2, 5007, 5005, 3, 2, 2, 2, 5007, 5008, 3, 2, 2, 2, 5008, 1064, 3, 2, 2, 2, 5009, 5007, 3, 2, 2, 2, 5010, 5011, 7, 71, 2, 2, 5011, 5012, 7, 41, 2, 2, 5012, 5013, 3, 2, 2, 2, 5013, 5014, 8, 531, 4, 2, 5014, 5015, 8, 531, 5, 2, 5015, 1066, 3, 2, 2, 2, 5016, 5017, 5, 1069, 533, 2, 5017, 5018, 7, 41, 2, 2, 5018, 1068, 3, 2, 2, 2, 5019, 5020, 7, 87, 2, 2, 5020, 5021, 7, 40, 2, 2, 5021, 5022, 5, 1063, 530, 2, 5022, 1070, 3, 2, 2, 2, 5023, 5025, 7, 38, 2, 2, 5024, 5026, 5, 1073, 535, 2, 5025, 5024, 3, 2, 2, 2, 5025, 5026, 3, 2, 2, 2, 5026, 5027, 3, 2, 2, 2, 5027, 5028, 7, 38, 2, 2, 5028, 5029, 8, 534, 6, 2, 5029, 5030, 3, 2, 2, 2, 5030, 5031, 8, 534, 7, 2, 5031, 1072, 3, 2, 2, 2, 5032, 5036, 5, 1039, 518, 2, 5033, 5035, 5, 1043, 520, 2, 5034, 5033, 3, 2, 2, 2, 5035, 5038, 3, 2, 2, 2, 5036, 5034, 3, 2, 2, 2, 5036, 5037, 3, 2, 2, 2, 5037, 1074, 3, 2, 2, 2, 5038, 5036, 3, 2, 2, 2, 5039, 5040, 5, 1077, 537, 2, 5040, 5041, 7, 41, 2, 2, 5041, 1076, 3, 2, 2, 2, 5042, 5043, 7, 68, 2, 2, 5043, 5047, 7, 41, 2, 2, 5044, 5046, 9, 14, 2, 2, 5045, 5044, 3, 2, 2, 2, 5046, 5049, 3, 2, 2, 2, 5047, 5045, 3, 2, 2, 2, 5047, 5048, 3, 2, 2, 2, 5048, 1078, 3, 2, 2, 2, 5049, 5047, 3, 2, 2, 2, 5050, 5051, 5, 1081, 539, 2, 5051, 5052, 7, 41, 2, 2, 5052, 1080, 3, 2, 2, 2, 5053, 5054, 7, 68, 2, 2, 5054, 5055, 5, 1063, 530, 2, 5055, 1082, 3, 2, 2, 2, 5056, 5057, 5, 1085, 541, 2, 5057, 5058, 7, 41, 2, 2, 5058, 1084, 3, 2, 2, 2, 5059, 5060, 7, 90, 2, 2, 5060, 5064, 7, 41, 2, 2, 5061, 5063, 9, 15, 2, 2, 5062, 5061, 3, 2, 2, 2, 5063, 5066, 3, 2, 2, 2, 5064, 5062, 3, 2, 2, 2, 5064, 5065, 3, 2, 2, 2, 5065, 1086, 3, 2, 2, 2, 5066, 5064, 3, 2, 2, 2, 5067, 5068, 5, 1089, 543, 2, 5068, 5069, 7, 41, 2, 2, 5069, 1088, 3, 2, 2, 2, 5070, 5071, 7, 90, 2, 2, 5071, 5072, 5, 1063, 530, 2, 5072, 1090, 3, 2, 2, 2, 5073, 5074, 5, 1097, 547, 2, 5074, 1092, 3, 2, 2, 2, 5075, 5076, 5, 1097, 547, 2, 5076, 5077, 7, 48, 2, 2, 5077, 5078, 7, 48, 2, 2, 5078, 5079, 3, 2, 2, 2, 5079, 5080, 8, 545, 8, 2, 5080, 1094, 3, 2, 2, 2, 5081, 5082, 5, 1097, 547, 2, 5082, 5084, 7, 48, 2, 2, 5083, 5085, 5, 1097, 547, 2, 5084, 5083, 3, 2, 2, 2, 5084, 5085, 3, 2, 2, 2, 5085, 5091, 3, 2, 2, 2, 5086, 5088, 7, 71, 2, 2, 5087, 5089, 9, 3, 2, 2, 5088, 5087, 3, 2, 2, 2, 5088, 5089, 3, 2, 2, 2, 5089, 5090, 3, 2, 2, 2, 5090, 5092, 5, 1097, 547, 2, 5091, 5086, 3, 2, 2, 2, 5091, 5092, 3, 2, 2, 2, 5092, 5110, 3, 2, 2, 2, 5093, 5094, 7, 48, 2, 2, 5094, 5100, 5, 1097, 547, 2, 5095, 5097, 7, 71, 2, 2, 5096, 5098, 9, 3, 2, 2, 5097, 5096, 3, 2, 2, 2, 5097, 5098, 3, 2, 2, 2, 5098, 5099, 3, 2, 2, 2, 5099, 5101, 5, 1097, 547, 2, 5100, 5095, 3, 2, 2, 2, 5100, 5101, 3, 2, 2, 2, 5101, 5110, 3, 2, 2, 2, 5102, 5103, 5, 1097, 547, 2, 5103, 5105, 7, 71, 2, 2, 5104, 5106, 9, 3, 2, 2, 5105, 5104, 3, 2, 2, 2, 5105, 5106, 3, 2, 2, 2, 5106, 5107, 3, 2, 2, 2, 5107, 5108, 5, 1097, 547, 2, 5108, 5110, 3, 2, 2, 2, 5109, 5081, 3, 2, 2, 2, 5109, 5093, 3, 2, 2, 2, 5109, 5102, 3, 2, 2, 2, 5110, 1096, 3, 2, 2, 2, 5111, 5113, 9, 2, 2, 2, 5112, 5111, 3, 2, 2, 2, 5113, 5114, 3, 2, 2, 2, 5114, 5112, 3, 2, 2, 2, 5114, 5115, 3, 2, 2, 2, 5115, 1098, 3, 2, 2, 2, 5116, 5117, 7, 60, 2, 2, 5117, 5121, 9, 16, 2, 2, 5118, 5120, 9, 17, 2, 2, 5119, 5118, 3, 2, 2, 2, 5120, 5123, 3, 2, 2, 2, 5121, 5119, 3, 2, 2, 2, 5121, 5122, 3, 2, 2, 2, 5122, 1100, 3, 2, 2, 2, 5123, 5121, 3, 2, 2, 2, 5124, 5125, 7, 60, 2, 2, 5125, 5126, 7, 36, 2, 2, 5126, 5134, 3, 2, 2, 2, 5127, 5128, 7, 94, 2, 2, 5128, 5133, 11, 2, 2, 2, 5129, 5130, 7, 36, 2, 2, 5130, 5133, 7, 36, 2, 2, 5131, 5133, 10, 18, 2, 2, 5132, 5127, 3, 2, 2, 2, 5132, 5129, 3, 2, 2, 2, 5132, 5131, 3, 2, 2, 2, 5133, 5136, 3, 2, 2, 2, 5134, 5132, 3, 2, 2, 2, 5134, 5135, 3, 2, 2, 2, 5135, 5137, 3, 2, 2, 2, 5136, 5134, 3, 2, 2, 2, 5137, 5138, 7, 36, 2, 2, 5138, 1102, 3, 2, 2, 2, 5139, 5141, 9, 19, 2, 2, 5140, 5139, 3, 2, 2, 2, 5141, 5142, 3, 2, 2, 2, 5142, 5140, 3, 2, 2, 2, 5142, 5143, 3, 2, 2, 2, 5143, 5144, 3, 2, 2, 2, 5144, 5145, 8, 550, 9, 2, 5145, 1104, 3, 2, 2, 2, 5146, 5148, 7, 15, 2, 2, 5147, 5149, 7, 12, 2, 2, 5148, 5147, 3, 2, 2, 2, 5148, 5149, 3, 2, 2, 2, 5149, 5152, 3, 2, 2, 2, 5150, 5152, 7, 12, 2, 2, 5151, 5146, 3, 2, 2, 2, 5151, 5150, 3, 2, 2, 2, 5152, 5153, 3, 2, 2, 2, 5153, 5154, 8, 551, 9, 2, 5154, 1106, 3, 2, 2, 2, 5155, 5156, 7, 47, 2, 2, 5156, 5157, 7, 47, 2, 2, 5157, 5161, 3, 2, 2, 2, 5158, 5160, 10, 20, 2, 2, 5159, 5158, 3, 2, 2, 2, 5160, 5163, 3, 2, 2, 2, 5161, 5159, 3, 2, 2, 2, 5161, 5162, 3, 2, 2, 2, 5162, 5164, 3, 2, 2, 2, 5163, 5161, 3, 2, 2, 2, 5164, 5165, 8, 552, 9, 2, 5165, 1108, 3, 2, 2, 2, 5166, 5167, 7, 49, 2, 2, 5167, 5168, 7, 44, 2, 2, 5168, 5191, 3, 2, 2, 2, 5169, 5171, 7, 49, 2, 2, 5170, 5169, 3, 2, 2, 2, 5171, 5174, 3, 2, 2, 2, 5172, 5170, 3, 2, 2, 2, 5172, 5173, 3, 2, 2, 2, 5173, 5175, 3, 2, 2, 2, 5174, 5172, 3, 2, 2, 2, 5175, 5190, 5, 1109, 553, 2, 5176, 5190, 10, 21, 2, 2, 5177, 5179, 7, 49, 2, 2, 5178, 5177, 3, 2, 2, 2, 5179, 5180, 3, 2, 2, 2, 5180, 5178, 3, 2, 2, 2, 5180, 5181, 3, 2, 2, 2, 5181, 5182, 3, 2, 2, 2, 5182, 5190, 10, 21, 2, 2, 5183, 5185, 7, 44, 2, 2, 5184, 5183, 3, 2, 2, 2, 5185, 5186, 3, 2, 2, 2, 5186, 5184, 3, 2, 2, 2, 5186, 5187, 3, 2, 2, 2, 5187, 5188, 3, 2, 2, 2, 5188, 5190, 10, 21, 2, 2, 5189, 5172, 3, 2, 2, 2, 5189, 5176, 3, 2, 2, 2, 5189, 5178, 3, 2, 2, 2, 5189, 5184, 3, 2, 2, 2, 5190, 5193, 3, 2, 2, 2, 5191, 5189, 3, 2, 2, 2, 5191, 5192, 3, 2, 2, 2, 5192, 5197, 3, 2, 2, 2, 5193, 5191, 3, 2, 2, 2, 5194, 5196, 7, 44, 2, 2, 5195, 5194, 3, 2, 2, 2, 5196, 5199, 3, 2, 2, 2, 5197, 5195, 3, 2, 2, 2, 5197, 5198, 3, 2, 2, 2, 5198, 5200, 3, 2, 2, 2, 5199, 5197, 3, 2, 2, 2, 5200, 5201, 7, 44, 2, 2, 5201, 5202, 7, 49, 2, 2, 5202, 5203, 3, 2, 2, 2, 5203, 5204, 8, 553, 9, 2, 5204, 1110, 3, 2, 2, 2, 5205, 5206, 7, 49, 2, 2, 5206, 5207, 7, 44, 2, 2, 5207, 5232, 3, 2, 2, 2, 5208, 5210, 7, 49, 2, 2, 5209, 5208, 3, 2, 2, 2, 5210, 5213, 3, 2, 2, 2, 5211, 5209, 3, 2, 2, 2, 5211, 5212, 3, 2, 2, 2, 5212, 5214, 3, 2, 2, 2, 5213, 5211, 3, 2, 2, 2, 5214, 5231, 5, 1109, 553, 2, 5215, 5231, 10, 21, 2, 2, 5216, 5218, 7, 49, 2, 2, 5217, 5216, 3, 2, 2, 2, 5218, 5219, 3, 2, 2, 2, 5219, 5217, 3, 2, 2, 2, 5219, 5220, 3, 2, 2, 2, 5220, 5221, 3, 2, 2, 2, 5221, 5229, 10, 21, 2, 2, 5222, 5224, 7, 44, 2, 2, 5223, 5222, 3, 2, 2, 2, 5224, 5225, 3, 2, 2, 2, 5225, 5223, 3, 2, 2, 2, 5225, 5226, 3, 2, 2, 2, 5226, 5227, 3, 2, 2, 2, 5227, 5229, 10, 21, 2, 2, 5228, 5217, 3, 2, 2, 2, 5228, 5223, 3, 2, 2, 2, 5229, 5231, 3, 2, 2, 2, 5230, 5211, 3, 2, 2, 2, 5230, 5215, 3, 2, 2, 2, 5230, 5228, 3, 2, 2, 2, 5231, 5234, 3, 2, 2, 2, 5232, 5230, 3, 2, 2, 2, 5232, 5233, 3, 2, 2, 2, 5233, 5252, 3, 2, 2, 2, 5234, 5232, 3, 2, 2, 2, 5235, 5237, 7, 49, 2, 2, 5236, 5235, 3, 2, 2, 2, 5237, 5238, 3, 2, 2, 2, 5238, 5236, 3, 2, 2, 2, 5238, 5239, 3, 2, 2, 2, 5239, 5253, 3, 2, 2, 2, 5240, 5242, 7, 44, 2, 2, 5241, 5240, 3, 2, 2, 2, 5242, 5243, 3, 2, 2, 2, 5243, 5241, 3, 2, 2, 2, 5243, 5244, 3, 2, 2, 2, 5244, 5253, 3, 2, 2, 2, 5245, 5247, 7, 49, 2, 2, 5246, 5245, 3, 2, 2, 2, 5247, 5250, 3, 2, 2, 2, 5248, 5246, 3, 2, 2, 2, 5248, 5249, 3, 2, 2, 2, 5249, 5251, 3, 2, 2, 2, 5250, 5248, 3, 2, 2, 2, 5251, 5253, 5, 1111, 554, 2, 5252, 5236, 3, 2, 2, 2, 5252, 5241, 3, 2, 2, 2, 5252, 5248, 3, 2, 2, 2, 5252, 5253, 3, 2, 2, 2, 5253, 5254, 3, 2, 2, 2, 5254, 5255, 8, 554, 10, 2, 5255, 1112, 3, 2, 2, 2, 5256, 5268, 7, 94, 2, 2, 5257, 5267, 10, 22, 2, 2, 5258, 5262, 7, 36, 2, 2, 5259, 5261, 10, 23, 2, 2, 5260, 5259, 3, 2, 2, 2, 5261, 5264, 3, 2, 2, 2, 5262, 5260, 3, 2, 2, 2, 5262, 5263, 3, 2, 2, 2, 5263, 5265, 3, 2, 2, 2, 5264, 5262, 3, 2, 2, 2, 5265, 5267, 7, 36, 2, 2, 5266, 5257, 3, 2, 2, 2, 5266, 5258, 3, 2, 2, 2, 5267, 5270, 3, 2, 2, 2, 5268, 5266, 3, 2, 2, 2, 5268, 5269, 3, 2, 2, 2, 5269, 5278, 3, 2, 2, 2, 5270, 5268, 3, 2, 2, 2, 5271, 5275, 7, 36, 2, 2, 5272, 5274, 10, 23, 2, 2, 5273, 5272, 3, 2, 2, 2, 5274, 5277, 3, 2, 2, 2, 5275, 5273, 3, 2, 2, 2, 5275, 5276, 3, 2, 2, 2, 5276, 5279, 3, 2, 2, 2, 5277, 5275, 3, 2, 2, 2, 5278, 5271, 3, 2, 2, 2, 5278, 5279, 3, 2, 2, 2, 5279, 1114, 3, 2, 2, 2, 5280, 5281, 7, 94, 2, 2, 5281, 5282, 7, 94, 2, 2, 5282, 1116, 3, 2, 2, 2, 5283, 5284, 11, 2, 2, 2, 5284, 1118, 3, 2, 2, 2, 5285, 5286, 5, 1123, 560, 2, 5286, 5287, 7, 41, 2, 2, 5287, 5288, 3, 2, 2, 2, 5288, 5289, 8, 558, 11, 2, 5289, 1120, 3, 2, 2, 2, 5290, 5292, 5, 1123, 560, 2, 5291, 5293, 7, 94, 2, 2, 5292, 5291, 3, 2, 2, 2, 5292, 5293, 3, 2, 2, 2, 5293, 5294, 3, 2, 2, 2, 5294, 5295, 7, 2, 2, 3, 5295, 1122, 3, 2, 2, 2, 5296, 5297, 7, 41, 2, 2, 5297, 5320, 7, 41, 2, 2, 5298, 5316, 7, 94, 2, 2, 5299, 5300, 7, 122, 2, 2, 5300, 5317, 9, 24, 2, 2, 5301, 5302, 7, 119, 2, 2, 5302, 5303, 9, 24, 2, 2, 5303, 5304, 9, 24, 2, 2, 5304, 5305, 9, 24, 2, 2, 5305, 5317, 9, 24, 2, 2, 5306, 5307, 7, 87, 2, 2, 5307, 5308, 9, 24, 2, 2, 5308, 5309, 9, 24, 2, 2, 5309, 5310, 9, 24, 2, 2, 5310, 5311, 9, 24, 2, 2, 5311, 5312, 9, 24, 2, 2, 5312, 5313, 9, 24, 2, 2, 5313, 5314, 9, 24, 2, 2, 5314, 5317, 9, 24, 2, 2, 5315, 5317, 10, 25, 2, 2, 5316, 5299, 3, 2, 2, 2, 5316, 5301, 3, 2, 2, 2, 5316, 5306, 3, 2, 2, 2, 5316, 5315, 3, 2, 2, 2, 5317, 5320, 3, 2, 2, 2, 5318, 5320, 10, 26, 2, 2, 5319, 5296, 3, 2, 2, 2, 5319, 5298, 3, 2, 2, 2, 5319, 5318, 3, 2, 2, 2, 5320, 5323, 3, 2, 2, 2, 5321, 5319, 3, 2, 2, 2, 5321, 5322, 3, 2, 2, 2, 5322, 1124, 3, 2, 2, 2, 5323, 5321, 3, 2, 2, 2, 5324, 5325, 5, 1129, 563, 2, 5325, 5326, 7, 41, 2, 2, 5326, 5327, 3, 2, 2, 2, 5327, 5328, 8, 561, 11, 2, 5328, 1126, 3, 2, 2, 2, 5329, 5331, 5, 1129, 563, 2, 5330, 5332, 7, 94, 2, 2, 5331, 5330, 3, 2, 2, 2, 5331, 5332, 3, 2, 2, 2, 5332, 5333, 3, 2, 2, 2, 5333, 5334, 7, 2, 2, 3, 5334, 1128, 3, 2, 2, 2, 5335, 5336, 7, 41, 2, 2, 5336, 5341, 7, 41, 2, 2, 5337, 5338, 7, 94, 2, 2, 5338, 5341, 11, 2, 2, 2, 5339, 5341, 10, 26, 2, 2, 5340, 5335, 3, 2, 2, 2, 5340, 5337, 3, 2, 2, 2, 5340, 5339, 3, 2, 2, 2, 5341, 5344, 3, 2, 2, 2, 5342, 5340, 3, 2, 2, 2, 5342, 5343, 3, 2, 2, 2, 5343, 1130, 3, 2, 2, 2, 5344, 5342, 3, 2, 2, 2, 5345, 5346, 5, 1103, 550, 2, 5346, 5347, 3, 2, 2, 2, 5347, 5348, 8, 564, 12, 2, 5348, 5349, 8, 564, 9, 2, 5349, 1132, 3, 2, 2, 2, 5350, 5351, 5, 1105, 551, 2, 5351, 5352, 3, 2, 2, 2, 5352, 5353, 8, 565, 13, 2, 5353, 5354, 8, 565, 9, 2, 5354, 5355, 8, 565, 14, 2, 5355, 1134, 3, 2, 2, 2, 5356, 5357, 8, 566, 15, 2, 5357, 5358, 3, 2, 2, 2, 5358, 5359, 8, 566, 16, 2, 5359, 5360, 8, 566, 17, 2, 5360, 1136, 3, 2, 2, 2, 5361, 5362, 5, 1103, 550, 2, 5362, 5363, 3, 2, 2, 2, 5363, 5364, 8, 567, 12, 2, 5364, 5365, 8, 567, 9, 2, 5365, 1138, 3, 2, 2, 2, 5366, 5367, 5, 1105, 551, 2, 5367, 5368, 3, 2, 2, 2, 5368, 5369, 8, 568, 13, 2, 5369, 5370, 8, 568, 9, 2, 5370, 1140, 3, 2, 2, 2, 5371, 5372, 7, 41, 2, 2, 5372, 5373, 3, 2, 2, 2, 5373, 5374, 8, 569, 4, 2, 5374, 5375, 8, 569, 18, 2, 5375, 1142, 3, 2, 2, 2, 5376, 5377, 8, 570, 19, 2, 5377, 5378, 3, 2, 2, 2, 5378, 5379, 8, 570, 16, 2, 5379, 5380, 8, 570, 17, 2, 5380, 1144, 3, 2, 2, 2, 5381, 5383, 10, 27, 2, 2, 5382, 5381, 3, 2, 2, 2, 5383, 5384, 3, 2, 2, 2, 5384, 5382, 3, 2, 2, 2, 5384, 5385, 3, 2, 2, 2, 5385, 5394, 3, 2, 2, 2, 5386, 5390, 7, 38, 2, 2, 5387, 5389, 10, 27, 2, 2, 5388, 5387, 3, 2, 2, 2, 5389, 5392, 3, 2, 2, 2, 5390, 5388, 3, 2, 2, 2, 5390, 5391, 3, 2, 2, 2, 5391, 5394, 3, 2, 2, 2, 5392, 5390, 3, 2, 2, 2, 5393, 5382, 3, 2, 2, 2, 5393, 5386, 3, 2, 2, 2, 5394, 1146, 3, 2, 2, 2, 5395, 5397, 7, 38, 2, 2, 5396, 5398, 5, 1073, 535, 2, 5397, 5396, 3, 2, 2, 2, 5397, 5398, 3, 2, 2, 2, 5398, 5399, 3, 2, 2, 2, 5399, 5400, 7, 38, 2, 2, 5400, 5401, 3, 2, 2, 2, 5401, 5402, 6, 572, 10, 2, 5402, 5403, 8, 572, 20, 2, 5403, 5404, 3, 2, 2, 2, 5404, 5405, 8, 572, 17, 2, 5405, 1148, 3, 2, 2, 2, 80, 2, 3, 4, 5, 6, 1216, 1222, 1224, 1229, 1233, 1235, 1238, 1247, 1249, 1254, 1259, 1261, 4939, 4948, 4952, 4956, 4965, 4967, 4977, 4979, 5005, 5007, 5025, 5036, 5047, 5064, 5084, 5088, 5091, 5097, 5100, 5105, 5109, 5114, 5121, 5132, 5134, 5142, 5148, 5151, 5161, 5172, 5180, 5186, 5189, 5191, 5197, 5211, 5219, 5225, 5228, 5230, 5232, 5238, 5243, 5248, 5252, 5262, 5266, 5268, 5275, 5278, 5292, 5316, 5319, 5321, 5331, 5340, 5342, 5384, 5390, 5393, 5397, 21, 3, 30, 2, 9, 31, 2, 5, 2, 2, 7, 3, 2, 3, 534, 3, 7, 6, 2, 3, 545, 4, 2, 3, 2, 3, 554, 5, 4, 4, 2, 9, 541, 2, 9, 542, 2, 4, 5, 2, 3, 566, 6, 8, 2, 2, 6, 2, 2, 4, 3, 2, 3, 570, 7, 3, 572, 8] \ No newline at end of file diff --git a/src/lib/pgsql/PostgreSQLLexer.js b/src/lib/pgsql/PostgreSQLLexer.js new file mode 100644 index 0000000..e304c68 --- /dev/null +++ b/src/lib/pgsql/PostgreSQLLexer.js @@ -0,0 +1,4873 @@ +// Generated from /Users/salvo/dt-sql-parser2/src/grammar/pgsql/PostgreSQLLexer.g4 by ANTLR 4.8 +// jshint ignore: start +var antlr4 = require('antlr4/index'); + + + + +var PostgreSQLLexerBase = require('./base/PostgreSQLLexerBase').PostgreSQLLexerBase; + + +var serializedATN = ["\u0003\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964", + "\u0002\u022d\u151e\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\u0004\u0002", + "\t\u0002\u0004\u0003\t\u0003\u0004\u0004\t\u0004\u0004\u0005\t\u0005", + "\u0004\u0006\t\u0006\u0004\u0007\t\u0007\u0004\b\t\b\u0004\t\t\t\u0004", + "\n\t\n\u0004\u000b\t\u000b\u0004\f\t\f\u0004\r\t\r\u0004\u000e\t\u000e", + "\u0004\u000f\t\u000f\u0004\u0010\t\u0010\u0004\u0011\t\u0011\u0004\u0012", + "\t\u0012\u0004\u0013\t\u0013\u0004\u0014\t\u0014\u0004\u0015\t\u0015", + "\u0004\u0016\t\u0016\u0004\u0017\t\u0017\u0004\u0018\t\u0018\u0004\u0019", + "\t\u0019\u0004\u001a\t\u001a\u0004\u001b\t\u001b\u0004\u001c\t\u001c", + "\u0004\u001d\t\u001d\u0004\u001e\t\u001e\u0004\u001f\t\u001f\u0004 ", + "\t \u0004!\t!\u0004\"\t\"\u0004#\t#\u0004$\t$\u0004%\t%\u0004&\t&\u0004", + "\'\t\'\u0004(\t(\u0004)\t)\u0004*\t*\u0004+\t+\u0004,\t,\u0004-\t-\u0004", + ".\t.\u0004/\t/\u00040\t0\u00041\t1\u00042\t2\u00043\t3\u00044\t4\u0004", + "5\t5\u00046\t6\u00047\t7\u00048\t8\u00049\t9\u0004:\t:\u0004;\t;\u0004", + "<\t<\u0004=\t=\u0004>\t>\u0004?\t?\u0004@\t@\u0004A\tA\u0004B\tB\u0004", + "C\tC\u0004D\tD\u0004E\tE\u0004F\tF\u0004G\tG\u0004H\tH\u0004I\tI\u0004", + "J\tJ\u0004K\tK\u0004L\tL\u0004M\tM\u0004N\tN\u0004O\tO\u0004P\tP\u0004", + "Q\tQ\u0004R\tR\u0004S\tS\u0004T\tT\u0004U\tU\u0004V\tV\u0004W\tW\u0004", + "X\tX\u0004Y\tY\u0004Z\tZ\u0004[\t[\u0004\\\t\\\u0004]\t]\u0004^\t^\u0004", + "_\t_\u0004`\t`\u0004a\ta\u0004b\tb\u0004c\tc\u0004d\td\u0004e\te\u0004", + "f\tf\u0004g\tg\u0004h\th\u0004i\ti\u0004j\tj\u0004k\tk\u0004l\tl\u0004", + "m\tm\u0004n\tn\u0004o\to\u0004p\tp\u0004q\tq\u0004r\tr\u0004s\ts\u0004", + "t\tt\u0004u\tu\u0004v\tv\u0004w\tw\u0004x\tx\u0004y\ty\u0004z\tz\u0004", + "{\t{\u0004|\t|\u0004}\t}\u0004~\t~\u0004\u007f\t\u007f\u0004\u0080\t", + "\u0080\u0004\u0081\t\u0081\u0004\u0082\t\u0082\u0004\u0083\t\u0083\u0004", + "\u0084\t\u0084\u0004\u0085\t\u0085\u0004\u0086\t\u0086\u0004\u0087\t", + "\u0087\u0004\u0088\t\u0088\u0004\u0089\t\u0089\u0004\u008a\t\u008a\u0004", + "\u008b\t\u008b\u0004\u008c\t\u008c\u0004\u008d\t\u008d\u0004\u008e\t", + "\u008e\u0004\u008f\t\u008f\u0004\u0090\t\u0090\u0004\u0091\t\u0091\u0004", + "\u0092\t\u0092\u0004\u0093\t\u0093\u0004\u0094\t\u0094\u0004\u0095\t", + "\u0095\u0004\u0096\t\u0096\u0004\u0097\t\u0097\u0004\u0098\t\u0098\u0004", + "\u0099\t\u0099\u0004\u009a\t\u009a\u0004\u009b\t\u009b\u0004\u009c\t", + "\u009c\u0004\u009d\t\u009d\u0004\u009e\t\u009e\u0004\u009f\t\u009f\u0004", + "\u00a0\t\u00a0\u0004\u00a1\t\u00a1\u0004\u00a2\t\u00a2\u0004\u00a3\t", + "\u00a3\u0004\u00a4\t\u00a4\u0004\u00a5\t\u00a5\u0004\u00a6\t\u00a6\u0004", + "\u00a7\t\u00a7\u0004\u00a8\t\u00a8\u0004\u00a9\t\u00a9\u0004\u00aa\t", + "\u00aa\u0004\u00ab\t\u00ab\u0004\u00ac\t\u00ac\u0004\u00ad\t\u00ad\u0004", + "\u00ae\t\u00ae\u0004\u00af\t\u00af\u0004\u00b0\t\u00b0\u0004\u00b1\t", + "\u00b1\u0004\u00b2\t\u00b2\u0004\u00b3\t\u00b3\u0004\u00b4\t\u00b4\u0004", + "\u00b5\t\u00b5\u0004\u00b6\t\u00b6\u0004\u00b7\t\u00b7\u0004\u00b8\t", + "\u00b8\u0004\u00b9\t\u00b9\u0004\u00ba\t\u00ba\u0004\u00bb\t\u00bb\u0004", + "\u00bc\t\u00bc\u0004\u00bd\t\u00bd\u0004\u00be\t\u00be\u0004\u00bf\t", + "\u00bf\u0004\u00c0\t\u00c0\u0004\u00c1\t\u00c1\u0004\u00c2\t\u00c2\u0004", + "\u00c3\t\u00c3\u0004\u00c4\t\u00c4\u0004\u00c5\t\u00c5\u0004\u00c6\t", + "\u00c6\u0004\u00c7\t\u00c7\u0004\u00c8\t\u00c8\u0004\u00c9\t\u00c9\u0004", + "\u00ca\t\u00ca\u0004\u00cb\t\u00cb\u0004\u00cc\t\u00cc\u0004\u00cd\t", + "\u00cd\u0004\u00ce\t\u00ce\u0004\u00cf\t\u00cf\u0004\u00d0\t\u00d0\u0004", + "\u00d1\t\u00d1\u0004\u00d2\t\u00d2\u0004\u00d3\t\u00d3\u0004\u00d4\t", + "\u00d4\u0004\u00d5\t\u00d5\u0004\u00d6\t\u00d6\u0004\u00d7\t\u00d7\u0004", + "\u00d8\t\u00d8\u0004\u00d9\t\u00d9\u0004\u00da\t\u00da\u0004\u00db\t", + "\u00db\u0004\u00dc\t\u00dc\u0004\u00dd\t\u00dd\u0004\u00de\t\u00de\u0004", + "\u00df\t\u00df\u0004\u00e0\t\u00e0\u0004\u00e1\t\u00e1\u0004\u00e2\t", + "\u00e2\u0004\u00e3\t\u00e3\u0004\u00e4\t\u00e4\u0004\u00e5\t\u00e5\u0004", + "\u00e6\t\u00e6\u0004\u00e7\t\u00e7\u0004\u00e8\t\u00e8\u0004\u00e9\t", + "\u00e9\u0004\u00ea\t\u00ea\u0004\u00eb\t\u00eb\u0004\u00ec\t\u00ec\u0004", + "\u00ed\t\u00ed\u0004\u00ee\t\u00ee\u0004\u00ef\t\u00ef\u0004\u00f0\t", + "\u00f0\u0004\u00f1\t\u00f1\u0004\u00f2\t\u00f2\u0004\u00f3\t\u00f3\u0004", + "\u00f4\t\u00f4\u0004\u00f5\t\u00f5\u0004\u00f6\t\u00f6\u0004\u00f7\t", + "\u00f7\u0004\u00f8\t\u00f8\u0004\u00f9\t\u00f9\u0004\u00fa\t\u00fa\u0004", + "\u00fb\t\u00fb\u0004\u00fc\t\u00fc\u0004\u00fd\t\u00fd\u0004\u00fe\t", + "\u00fe\u0004\u00ff\t\u00ff\u0004\u0100\t\u0100\u0004\u0101\t\u0101\u0004", + "\u0102\t\u0102\u0004\u0103\t\u0103\u0004\u0104\t\u0104\u0004\u0105\t", + "\u0105\u0004\u0106\t\u0106\u0004\u0107\t\u0107\u0004\u0108\t\u0108\u0004", + "\u0109\t\u0109\u0004\u010a\t\u010a\u0004\u010b\t\u010b\u0004\u010c\t", + "\u010c\u0004\u010d\t\u010d\u0004\u010e\t\u010e\u0004\u010f\t\u010f\u0004", + "\u0110\t\u0110\u0004\u0111\t\u0111\u0004\u0112\t\u0112\u0004\u0113\t", + "\u0113\u0004\u0114\t\u0114\u0004\u0115\t\u0115\u0004\u0116\t\u0116\u0004", + "\u0117\t\u0117\u0004\u0118\t\u0118\u0004\u0119\t\u0119\u0004\u011a\t", + "\u011a\u0004\u011b\t\u011b\u0004\u011c\t\u011c\u0004\u011d\t\u011d\u0004", + "\u011e\t\u011e\u0004\u011f\t\u011f\u0004\u0120\t\u0120\u0004\u0121\t", + "\u0121\u0004\u0122\t\u0122\u0004\u0123\t\u0123\u0004\u0124\t\u0124\u0004", + "\u0125\t\u0125\u0004\u0126\t\u0126\u0004\u0127\t\u0127\u0004\u0128\t", + "\u0128\u0004\u0129\t\u0129\u0004\u012a\t\u012a\u0004\u012b\t\u012b\u0004", + "\u012c\t\u012c\u0004\u012d\t\u012d\u0004\u012e\t\u012e\u0004\u012f\t", + "\u012f\u0004\u0130\t\u0130\u0004\u0131\t\u0131\u0004\u0132\t\u0132\u0004", + "\u0133\t\u0133\u0004\u0134\t\u0134\u0004\u0135\t\u0135\u0004\u0136\t", + "\u0136\u0004\u0137\t\u0137\u0004\u0138\t\u0138\u0004\u0139\t\u0139\u0004", + "\u013a\t\u013a\u0004\u013b\t\u013b\u0004\u013c\t\u013c\u0004\u013d\t", + "\u013d\u0004\u013e\t\u013e\u0004\u013f\t\u013f\u0004\u0140\t\u0140\u0004", + "\u0141\t\u0141\u0004\u0142\t\u0142\u0004\u0143\t\u0143\u0004\u0144\t", + "\u0144\u0004\u0145\t\u0145\u0004\u0146\t\u0146\u0004\u0147\t\u0147\u0004", + "\u0148\t\u0148\u0004\u0149\t\u0149\u0004\u014a\t\u014a\u0004\u014b\t", + "\u014b\u0004\u014c\t\u014c\u0004\u014d\t\u014d\u0004\u014e\t\u014e\u0004", + "\u014f\t\u014f\u0004\u0150\t\u0150\u0004\u0151\t\u0151\u0004\u0152\t", + "\u0152\u0004\u0153\t\u0153\u0004\u0154\t\u0154\u0004\u0155\t\u0155\u0004", + "\u0156\t\u0156\u0004\u0157\t\u0157\u0004\u0158\t\u0158\u0004\u0159\t", + "\u0159\u0004\u015a\t\u015a\u0004\u015b\t\u015b\u0004\u015c\t\u015c\u0004", + "\u015d\t\u015d\u0004\u015e\t\u015e\u0004\u015f\t\u015f\u0004\u0160\t", + "\u0160\u0004\u0161\t\u0161\u0004\u0162\t\u0162\u0004\u0163\t\u0163\u0004", + "\u0164\t\u0164\u0004\u0165\t\u0165\u0004\u0166\t\u0166\u0004\u0167\t", + "\u0167\u0004\u0168\t\u0168\u0004\u0169\t\u0169\u0004\u016a\t\u016a\u0004", + "\u016b\t\u016b\u0004\u016c\t\u016c\u0004\u016d\t\u016d\u0004\u016e\t", + "\u016e\u0004\u016f\t\u016f\u0004\u0170\t\u0170\u0004\u0171\t\u0171\u0004", + "\u0172\t\u0172\u0004\u0173\t\u0173\u0004\u0174\t\u0174\u0004\u0175\t", + "\u0175\u0004\u0176\t\u0176\u0004\u0177\t\u0177\u0004\u0178\t\u0178\u0004", + "\u0179\t\u0179\u0004\u017a\t\u017a\u0004\u017b\t\u017b\u0004\u017c\t", + "\u017c\u0004\u017d\t\u017d\u0004\u017e\t\u017e\u0004\u017f\t\u017f\u0004", + "\u0180\t\u0180\u0004\u0181\t\u0181\u0004\u0182\t\u0182\u0004\u0183\t", + "\u0183\u0004\u0184\t\u0184\u0004\u0185\t\u0185\u0004\u0186\t\u0186\u0004", + "\u0187\t\u0187\u0004\u0188\t\u0188\u0004\u0189\t\u0189\u0004\u018a\t", + "\u018a\u0004\u018b\t\u018b\u0004\u018c\t\u018c\u0004\u018d\t\u018d\u0004", + "\u018e\t\u018e\u0004\u018f\t\u018f\u0004\u0190\t\u0190\u0004\u0191\t", + "\u0191\u0004\u0192\t\u0192\u0004\u0193\t\u0193\u0004\u0194\t\u0194\u0004", + "\u0195\t\u0195\u0004\u0196\t\u0196\u0004\u0197\t\u0197\u0004\u0198\t", + "\u0198\u0004\u0199\t\u0199\u0004\u019a\t\u019a\u0004\u019b\t\u019b\u0004", + "\u019c\t\u019c\u0004\u019d\t\u019d\u0004\u019e\t\u019e\u0004\u019f\t", + "\u019f\u0004\u01a0\t\u01a0\u0004\u01a1\t\u01a1\u0004\u01a2\t\u01a2\u0004", + "\u01a3\t\u01a3\u0004\u01a4\t\u01a4\u0004\u01a5\t\u01a5\u0004\u01a6\t", + "\u01a6\u0004\u01a7\t\u01a7\u0004\u01a8\t\u01a8\u0004\u01a9\t\u01a9\u0004", + "\u01aa\t\u01aa\u0004\u01ab\t\u01ab\u0004\u01ac\t\u01ac\u0004\u01ad\t", + "\u01ad\u0004\u01ae\t\u01ae\u0004\u01af\t\u01af\u0004\u01b0\t\u01b0\u0004", + "\u01b1\t\u01b1\u0004\u01b2\t\u01b2\u0004\u01b3\t\u01b3\u0004\u01b4\t", + "\u01b4\u0004\u01b5\t\u01b5\u0004\u01b6\t\u01b6\u0004\u01b7\t\u01b7\u0004", + "\u01b8\t\u01b8\u0004\u01b9\t\u01b9\u0004\u01ba\t\u01ba\u0004\u01bb\t", + "\u01bb\u0004\u01bc\t\u01bc\u0004\u01bd\t\u01bd\u0004\u01be\t\u01be\u0004", + "\u01bf\t\u01bf\u0004\u01c0\t\u01c0\u0004\u01c1\t\u01c1\u0004\u01c2\t", + "\u01c2\u0004\u01c3\t\u01c3\u0004\u01c4\t\u01c4\u0004\u01c5\t\u01c5\u0004", + "\u01c6\t\u01c6\u0004\u01c7\t\u01c7\u0004\u01c8\t\u01c8\u0004\u01c9\t", + "\u01c9\u0004\u01ca\t\u01ca\u0004\u01cb\t\u01cb\u0004\u01cc\t\u01cc\u0004", + "\u01cd\t\u01cd\u0004\u01ce\t\u01ce\u0004\u01cf\t\u01cf\u0004\u01d0\t", + "\u01d0\u0004\u01d1\t\u01d1\u0004\u01d2\t\u01d2\u0004\u01d3\t\u01d3\u0004", + "\u01d4\t\u01d4\u0004\u01d5\t\u01d5\u0004\u01d6\t\u01d6\u0004\u01d7\t", + "\u01d7\u0004\u01d8\t\u01d8\u0004\u01d9\t\u01d9\u0004\u01da\t\u01da\u0004", + "\u01db\t\u01db\u0004\u01dc\t\u01dc\u0004\u01dd\t\u01dd\u0004\u01de\t", + "\u01de\u0004\u01df\t\u01df\u0004\u01e0\t\u01e0\u0004\u01e1\t\u01e1\u0004", + "\u01e2\t\u01e2\u0004\u01e3\t\u01e3\u0004\u01e4\t\u01e4\u0004\u01e5\t", + "\u01e5\u0004\u01e6\t\u01e6\u0004\u01e7\t\u01e7\u0004\u01e8\t\u01e8\u0004", + "\u01e9\t\u01e9\u0004\u01ea\t\u01ea\u0004\u01eb\t\u01eb\u0004\u01ec\t", + "\u01ec\u0004\u01ed\t\u01ed\u0004\u01ee\t\u01ee\u0004\u01ef\t\u01ef\u0004", + "\u01f0\t\u01f0\u0004\u01f1\t\u01f1\u0004\u01f2\t\u01f2\u0004\u01f3\t", + "\u01f3\u0004\u01f4\t\u01f4\u0004\u01f5\t\u01f5\u0004\u01f6\t\u01f6\u0004", + "\u01f7\t\u01f7\u0004\u01f8\t\u01f8\u0004\u01f9\t\u01f9\u0004\u01fa\t", + "\u01fa\u0004\u01fb\t\u01fb\u0004\u01fc\t\u01fc\u0004\u01fd\t\u01fd\u0004", + "\u01fe\t\u01fe\u0004\u01ff\t\u01ff\u0004\u0200\t\u0200\u0004\u0201\t", + "\u0201\u0004\u0202\t\u0202\u0004\u0203\t\u0203\u0004\u0204\t\u0204\u0004", + "\u0205\t\u0205\u0004\u0206\t\u0206\u0004\u0207\t\u0207\u0004\u0208\t", + "\u0208\u0004\u0209\t\u0209\u0004\u020a\t\u020a\u0004\u020b\t\u020b\u0004", + "\u020c\t\u020c\u0004\u020d\t\u020d\u0004\u020e\t\u020e\u0004\u020f\t", + "\u020f\u0004\u0210\t\u0210\u0004\u0211\t\u0211\u0004\u0212\t\u0212\u0004", + "\u0213\t\u0213\u0004\u0214\t\u0214\u0004\u0215\t\u0215\u0004\u0216\t", + "\u0216\u0004\u0217\t\u0217\u0004\u0218\t\u0218\u0004\u0219\t\u0219\u0004", + "\u021a\t\u021a\u0004\u021b\t\u021b\u0004\u021c\t\u021c\u0004\u021d\t", + "\u021d\u0004\u021e\t\u021e\u0004\u021f\t\u021f\u0004\u0220\t\u0220\u0004", + "\u0221\t\u0221\u0004\u0222\t\u0222\u0004\u0223\t\u0223\u0004\u0224\t", + "\u0224\u0004\u0225\t\u0225\u0004\u0226\t\u0226\u0004\u0227\t\u0227\u0004", + "\u0228\t\u0228\u0004\u0229\t\u0229\u0004\u022a\t\u022a\u0004\u022b\t", + "\u022b\u0004\u022c\t\u022c\u0004\u022d\t\u022d\u0004\u022e\t\u022e\u0004", + "\u022f\t\u022f\u0004\u0230\t\u0230\u0004\u0231\t\u0231\u0004\u0232\t", + "\u0232\u0004\u0233\t\u0233\u0004\u0234\t\u0234\u0004\u0235\t\u0235\u0004", + "\u0236\t\u0236\u0004\u0237\t\u0237\u0004\u0238\t\u0238\u0004\u0239\t", + "\u0239\u0004\u023a\t\u023a\u0004\u023b\t\u023b\u0004\u023c\t\u023c\u0003", + "\u0002\u0003\u0002\u0003\u0003\u0003\u0003\u0003\u0004\u0003\u0004\u0003", + "\u0005\u0003\u0005\u0003\u0006\u0003\u0006\u0003\u0007\u0003\u0007\u0003", + "\b\u0003\b\u0003\t\u0003\t\u0003\n\u0003\n\u0003\u000b\u0003\u000b\u0003", + "\f\u0003\f\u0003\r\u0003\r\u0003\u000e\u0003\u000e\u0003\u000f\u0003", + "\u000f\u0003\u0010\u0003\u0010\u0003\u0011\u0003\u0011\u0003\u0012\u0003", + "\u0012\u0003\u0013\u0003\u0013\u0003\u0013\u0003\u0014\u0003\u0014\u0003", + "\u0014\u0003\u0015\u0003\u0015\u0003\u0015\u0003\u0016\u0003\u0016\u0003", + "\u0016\u0003\u0017\u0003\u0017\u0003\u0017\u0003\u0018\u0003\u0018\u0003", + "\u0018\u0003\u0019\u0003\u0019\u0003\u0019\u0003\u001a\u0003\u001a\u0003", + "\u001a\u0003\u001b\u0003\u001b\u0003\u001b\u0003\u001c\u0003\u001c\u0003", + "\u001d\u0003\u001d\u0006\u001d\u04bf\n\u001d\r\u001d\u000e\u001d\u04c0", + "\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0006\u001e\u04c7\n", + "\u001e\r\u001e\u000e\u001e\u04c8\u0003\u001e\u0003\u001e\u0003\u001e", + "\u0005\u001e\u04ce\n\u001e\u0003\u001e\u0003\u001e\u0006\u001e\u04d2", + "\n\u001e\r\u001e\u000e\u001e\u04d3\u0003\u001e\u0005\u001e\u04d7\n\u001e", + "\u0003\u001e\u0003\u001e\u0003\u001f\u0003\u001f\u0003\u001f\u0003\u001f", + "\u0003\u001f\u0007\u001f\u04e0\n\u001f\f\u001f\u000e\u001f\u04e3\u000b", + "\u001f\u0003\u001f\u0003\u001f\u0005\u001f\u04e7\n\u001f\u0003\u001f", + "\u0003\u001f\u0003\u001f\u0006\u001f\u04ec\n\u001f\r\u001f\u000e\u001f", + "\u04ed\u0003\u001f\u0003\u001f\u0003 \u0003 \u0003!\u0003!\u0003\"\u0003", + "\"\u0003#\u0003#\u0003#\u0003#\u0003$\u0003$\u0003$\u0003$\u0003$\u0003", + "$\u0003$\u0003$\u0003%\u0003%\u0003%\u0003%\u0003%\u0003%\u0003%\u0003", + "%\u0003&\u0003&\u0003&\u0003&\u0003\'\u0003\'\u0003\'\u0003\'\u0003", + "(\u0003(\u0003(\u0003(\u0003(\u0003(\u0003)\u0003)\u0003)\u0003*\u0003", + "*\u0003*\u0003*\u0003+\u0003+\u0003+\u0003+\u0003+\u0003+\u0003+\u0003", + "+\u0003+\u0003+\u0003+\u0003,\u0003,\u0003,\u0003,\u0003,\u0003-\u0003", + "-\u0003-\u0003-\u0003-\u0003.\u0003.\u0003.\u0003.\u0003.\u0003/\u0003", + "/\u0003/\u0003/\u0003/\u0003/\u00030\u00030\u00030\u00030\u00030\u0003", + "0\u00030\u00030\u00031\u00031\u00031\u00031\u00031\u00031\u00031\u0003", + "2\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u0003", + "2\u00033\u00033\u00033\u00033\u00033\u00033\u00033\u00034\u00034\u0003", + "4\u00034\u00034\u00034\u00034\u00034\u00034\u00034\u00034\u00034\u0003", + "4\u00034\u00034\u00034\u00035\u00035\u00035\u00035\u00035\u00035\u0003", + "5\u00035\u00035\u00035\u00035\u00035\u00035\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "7\u00037\u00037\u00037\u00037\u00037\u00037\u00037\u00037\u00037\u0003", + "7\u00037\u00037\u00038\u00038\u00038\u00038\u00038\u00038\u00038\u0003", + "8\u00038\u00038\u00038\u00038\u00038\u00038\u00038\u00038\u00038\u0003", + "8\u00039\u00039\u00039\u00039\u00039\u00039\u00039\u00039\u00039\u0003", + "9\u00039\u00039\u00039\u0003:\u0003:\u0003:\u0003:\u0003:\u0003:\u0003", + ":\u0003:\u0003;\u0003;\u0003;\u0003;\u0003;\u0003;\u0003;\u0003;\u0003", + ";\u0003;\u0003;\u0003<\u0003<\u0003<\u0003<\u0003<\u0003=\u0003=\u0003", + "=\u0003=\u0003=\u0003=\u0003=\u0003=\u0003=\u0003>\u0003>\u0003>\u0003", + "?\u0003?\u0003?\u0003?\u0003?\u0003@\u0003@\u0003@\u0003@\u0003@\u0003", + "@\u0003@\u0003A\u0003A\u0003A\u0003A\u0003A\u0003A\u0003B\u0003B\u0003", + "B\u0003B\u0003B\u0003B\u0003C\u0003C\u0003C\u0003C\u0003D\u0003D\u0003", + "D\u0003D\u0003D\u0003D\u0003D\u0003D\u0003E\u0003E\u0003E\u0003E\u0003", + "E\u0003F\u0003F\u0003F\u0003F\u0003F\u0003F\u0003G\u0003G\u0003G\u0003", + "G\u0003G\u0003G\u0003H\u0003H\u0003H\u0003H\u0003H\u0003H\u0003H\u0003", + "I\u0003I\u0003I\u0003J\u0003J\u0003J\u0003J\u0003J\u0003J\u0003J\u0003", + "J\u0003J\u0003J\u0003K\u0003K\u0003K\u0003K\u0003K\u0003K\u0003K\u0003", + "K\u0003K\u0003K\u0003L\u0003L\u0003L\u0003L\u0003L\u0003M\u0003M\u0003", + "M\u0003M\u0003M\u0003M\u0003M\u0003M\u0003N\u0003N\u0003N\u0003N\u0003", + "N\u0003N\u0003N\u0003N\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003", + "P\u0003P\u0003P\u0003P\u0003P\u0003P\u0003P\u0003P\u0003P\u0003P\u0003", + "Q\u0003Q\u0003Q\u0003Q\u0003Q\u0003Q\u0003Q\u0003Q\u0003Q\u0003Q\u0003", + "Q\u0003Q\u0003Q\u0003Q\u0003Q\u0003R\u0003R\u0003R\u0003R\u0003S\u0003", + "S\u0003S\u0003S\u0003S\u0003T\u0003T\u0003T\u0003T\u0003T\u0003T\u0003", + "T\u0003U\u0003U\u0003U\u0003V\u0003V\u0003V\u0003V\u0003V\u0003W\u0003", + "W\u0003W\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003Y\u0003Y\u0003", + "Y\u0003Y\u0003Y\u0003Y\u0003Y\u0003Y\u0003Z\u0003Z\u0003Z\u0003Z\u0003", + "Z\u0003Z\u0003Z\u0003Z\u0003[\u0003[\u0003[\u0003[\u0003[\u0003[\u0003", + "[\u0003[\u0003[\u0003[\u0003[\u0003\\\u0003\\\u0003\\\u0003\\\u0003", + "\\\u0003\\\u0003\\\u0003\\\u0003\\\u0003\\\u0003]\u0003]\u0003]\u0003", + "]\u0003]\u0003]\u0003]\u0003^\u0003^\u0003^\u0003^\u0003^\u0003^\u0003", + "^\u0003^\u0003^\u0003^\u0003^\u0003^\u0003^\u0003_\u0003_\u0003_\u0003", + "_\u0003_\u0003`\u0003`\u0003`\u0003`\u0003`\u0003`\u0003`\u0003`\u0003", + "`\u0003`\u0003a\u0003a\u0003a\u0003a\u0003a\u0003a\u0003b\u0003b\u0003", + "b\u0003b\u0003b\u0003c\u0003c\u0003c\u0003d\u0003d\u0003d\u0003d\u0003", + "d\u0003d\u0003d\u0003d\u0003d\u0003e\u0003e\u0003e\u0003e\u0003e\u0003", + "f\u0003f\u0003f\u0003f\u0003f\u0003f\u0003g\u0003g\u0003g\u0003g\u0003", + "g\u0003g\u0003g\u0003h\u0003h\u0003h\u0003h\u0003h\u0003i\u0003i\u0003", + "i\u0003i\u0003i\u0003i\u0003j\u0003j\u0003j\u0003j\u0003j\u0003j\u0003", + "j\u0003j\u0003j\u0003k\u0003k\u0003k\u0003k\u0003k\u0003l\u0003l\u0003", + "l\u0003l\u0003l\u0003l\u0003m\u0003m\u0003m\u0003m\u0003m\u0003m\u0003", + "m\u0003n\u0003n\u0003n\u0003n\u0003n\u0003o\u0003o\u0003o\u0003o\u0003", + "o\u0003o\u0003o\u0003o\u0003o\u0003o\u0003o\u0003o\u0003o\u0003o\u0003", + "p\u0003p\u0003p\u0003p\u0003p\u0003p\u0003p\u0003q\u0003q\u0003q\u0003", + "q\u0003q\u0003q\u0003q\u0003q\u0003q\u0003q\u0003r\u0003r\u0003r\u0003", + "r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003r\u0003", + "s\u0003s\u0003s\u0003s\u0003s\u0003s\u0003t\u0003t\u0003t\u0003t\u0003", + "t\u0003t\u0003t\u0003t\u0003t\u0003t\u0003t\u0003t\u0003t\u0003t\u0003", + "t\u0003u\u0003u\u0003u\u0003u\u0003u\u0003u\u0003u\u0003v\u0003v\u0003", + "v\u0003v\u0003v\u0003w\u0003w\u0003w\u0003w\u0003w\u0003w\u0003x\u0003", + "x\u0003x\u0003x\u0003x\u0003x\u0003y\u0003y\u0003y\u0003z\u0003z\u0003", + "z\u0003z\u0003z\u0003z\u0003z\u0003{\u0003{\u0003{\u0003{\u0003{\u0003", + "|\u0003|\u0003|\u0003|\u0003|\u0003}\u0003}\u0003}\u0003}\u0003}\u0003", + "~\u0003~\u0003~\u0003~\u0003~\u0003~\u0003~\u0003~\u0003\u007f\u0003", + "\u007f\u0003\u007f\u0003\u007f\u0003\u007f\u0003\u007f\u0003\u007f\u0003", + "\u007f\u0003\u0080\u0003\u0080\u0003\u0080\u0003\u0080\u0003\u0080\u0003", + "\u0080\u0003\u0081\u0003\u0081\u0003\u0081\u0003\u0081\u0003\u0081\u0003", + "\u0082\u0003\u0082\u0003\u0082\u0003\u0082\u0003\u0082\u0003\u0082\u0003", + "\u0082\u0003\u0082\u0003\u0082\u0003\u0083\u0003\u0083\u0003\u0083\u0003", + "\u0083\u0003\u0083\u0003\u0083\u0003\u0084\u0003\u0084\u0003\u0084\u0003", + "\u0084\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0085\u0003", + "\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003", + "\u0085\u0003\u0086\u0003\u0086\u0003\u0086\u0003\u0086\u0003\u0086\u0003", + "\u0086\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003", + "\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0088\u0003\u0088\u0003", + "\u0088\u0003\u0088\u0003\u0088\u0003\u0088\u0003\u0088\u0003\u0089\u0003", + "\u0089\u0003\u0089\u0003\u0089\u0003\u0089\u0003\u0089\u0003\u0089\u0003", + "\u008a\u0003\u008a\u0003\u008a\u0003\u008a\u0003\u008b\u0003\u008b\u0003", + "\u008b\u0003\u008b\u0003\u008b\u0003\u008b\u0003\u008c\u0003\u008c\u0003", + "\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008d\u0003\u008d\u0003", + "\u008d\u0003\u008d\u0003\u008d\u0003\u008d\u0003\u008d\u0003\u008d\u0003", + "\u008d\u0003\u008d\u0003\u008e\u0003\u008e\u0003\u008e\u0003\u008e\u0003", + "\u008e\u0003\u008f\u0003\u008f\u0003\u008f\u0003\u008f\u0003\u008f\u0003", + "\u008f\u0003\u0090\u0003\u0090\u0003\u0090\u0003\u0090\u0003\u0090\u0003", + "\u0090\u0003\u0090\u0003\u0091\u0003\u0091\u0003\u0091\u0003\u0091\u0003", + "\u0091\u0003\u0091\u0003\u0091\u0003\u0091\u0003\u0091\u0003\u0091\u0003", + "\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003", + "\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0093\u0003", + "\u0093\u0003\u0093\u0003\u0094\u0003\u0094\u0003\u0094\u0003\u0094\u0003", + "\u0094\u0003\u0094\u0003\u0094\u0003\u0094\u0003\u0094\u0003\u0094\u0003", + "\u0095\u0003\u0095\u0003\u0095\u0003\u0095\u0003\u0095\u0003\u0095\u0003", + "\u0095\u0003\u0095\u0003\u0095\u0003\u0096\u0003\u0096\u0003\u0096\u0003", + "\u0096\u0003\u0096\u0003\u0096\u0003\u0096\u0003\u0097\u0003\u0097\u0003", + "\u0097\u0003\u0097\u0003\u0097\u0003\u0097\u0003\u0098\u0003\u0098\u0003", + "\u0098\u0003\u0099\u0003\u0099\u0003\u0099\u0003\u0099\u0003\u0099\u0003", + "\u0099\u0003\u009a\u0003\u009a\u0003\u009a\u0003\u009a\u0003\u009a\u0003", + "\u009a\u0003\u009a\u0003\u009b\u0003\u009b\u0003\u009b\u0003\u009b\u0003", + "\u009b\u0003\u009b\u0003\u009b\u0003\u009b\u0003\u009c\u0003\u009c\u0003", + "\u009c\u0003\u009c\u0003\u009c\u0003\u009c\u0003\u009c\u0003\u009c\u0003", + "\u009c\u0003\u009d\u0003\u009d\u0003\u009d\u0003\u009d\u0003\u009d\u0003", + "\u009d\u0003\u009d\u0003\u009d\u0003\u009e\u0003\u009e\u0003\u009e\u0003", + "\u009e\u0003\u009e\u0003\u009e\u0003\u009f\u0003\u009f\u0003\u009f\u0003", + "\u009f\u0003\u009f\u0003\u009f\u0003\u009f\u0003\u009f\u0003\u009f\u0003", + "\u009f\u0003\u009f\u0003\u009f\u0003\u009f\u0003\u009f\u0003\u009f\u0003", + "\u009f\u0003\u00a0\u0003\u00a0\u0003\u00a0\u0003\u00a0\u0003\u00a0\u0003", + "\u00a0\u0003\u00a0\u0003\u00a0\u0003\u00a0\u0003\u00a0\u0003\u00a0\u0003", + "\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003\u00a1\u0003", + "\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003", + "\u00a3\u0003\u00a3\u0003\u00a3\u0003\u00a3\u0003\u00a3\u0003\u00a3\u0003", + "\u00a3\u0003\u00a3\u0003\u00a4\u0003\u00a4\u0003\u00a4\u0003\u00a4\u0003", + "\u00a4\u0003\u00a4\u0003\u00a4\u0003\u00a4\u0003\u00a5\u0003\u00a5\u0003", + "\u00a5\u0003\u00a5\u0003\u00a5\u0003\u00a5\u0003\u00a5\u0003\u00a5\u0003", + "\u00a5\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003", + "\u00a6\u0003\u00a6\u0003\u00a7\u0003\u00a7\u0003\u00a7\u0003\u00a7\u0003", + "\u00a7\u0003\u00a7\u0003\u00a7\u0003\u00a7\u0003\u00a7\u0003\u00a7\u0003", + "\u00a8\u0003\u00a8\u0003\u00a8\u0003\u00a8\u0003\u00a8\u0003\u00a8\u0003", + "\u00a8\u0003\u00a8\u0003\u00a8\u0003\u00a8\u0003\u00a8\u0003\u00a8\u0003", + "\u00a8\u0003\u00a8\u0003\u00a9\u0003\u00a9\u0003\u00a9\u0003\u00a9\u0003", + "\u00a9\u0003\u00a9\u0003\u00a9\u0003\u00a9\u0003\u00a9\u0003\u00a9\u0003", + "\u00a9\u0003\u00aa\u0003\u00aa\u0003\u00aa\u0003\u00aa\u0003\u00aa\u0003", + "\u00aa\u0003\u00aa\u0003\u00aa\u0003\u00aa\u0003\u00aa\u0003\u00aa\u0003", + "\u00aa\u0003\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ab\u0003", + "\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ac\u0003\u00ac\u0003\u00ac\u0003", + "\u00ac\u0003\u00ac\u0003\u00ac\u0003\u00ac\u0003\u00ac\u0003\u00ac\u0003", + "\u00ad\u0003\u00ad\u0003\u00ad\u0003\u00ad\u0003\u00ad\u0003\u00ad\u0003", + "\u00ad\u0003\u00ad\u0003\u00ad\u0003\u00ad\u0003\u00ad\u0003\u00ae\u0003", + "\u00ae\u0003\u00ae\u0003\u00ae\u0003\u00ae\u0003\u00af\u0003\u00af\u0003", + "\u00af\u0003\u00af\u0003\u00af\u0003\u00b0\u0003\u00b0\u0003\u00b0\u0003", + "\u00b0\u0003\u00b1\u0003\u00b1\u0003\u00b1\u0003\u00b1\u0003\u00b1\u0003", + "\u00b1\u0003\u00b1\u0003\u00b2\u0003\u00b2\u0003\u00b2\u0003\u00b2\u0003", + "\u00b2\u0003\u00b2\u0003\u00b3\u0003\u00b3\u0003\u00b3\u0003\u00b3\u0003", + "\u00b3\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003", + "\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b5\u0003\u00b5\u0003", + "\u00b5\u0003\u00b5\u0003\u00b6\u0003\u00b6\u0003\u00b6\u0003\u00b6\u0003", + "\u00b6\u0003\u00b6\u0003\u00b6\u0003\u00b6\u0003\u00b6\u0003\u00b6\u0003", + "\u00b6\u0003\u00b7\u0003\u00b7\u0003\u00b7\u0003\u00b7\u0003\u00b7\u0003", + "\u00b7\u0003\u00b7\u0003\u00b7\u0003\u00b8\u0003\u00b8\u0003\u00b8\u0003", + "\u00b8\u0003\u00b8\u0003\u00b8\u0003\u00b8\u0003\u00b8\u0003\u00b8\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00ba\u0003\u00ba\u0003\u00ba\u0003", + "\u00ba\u0003\u00ba\u0003\u00ba\u0003\u00ba\u0003\u00ba\u0003\u00bb\u0003", + "\u00bb\u0003\u00bb\u0003\u00bb\u0003\u00bb\u0003\u00bb\u0003\u00bb\u0003", + "\u00bc\u0003\u00bc\u0003\u00bc\u0003\u00bc\u0003\u00bc\u0003\u00bc\u0003", + "\u00bc\u0003\u00bc\u0003\u00bc\u0003\u00bc\u0003\u00bd\u0003\u00bd\u0003", + "\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003", + "\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00be\u0003\u00be\u0003\u00be\u0003", + "\u00be\u0003\u00be\u0003\u00be\u0003\u00be\u0003\u00be\u0003\u00be\u0003", + "\u00be\u0003\u00be\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003", + "\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00c0\u0003\u00c0\u0003", + "\u00c0\u0003\u00c0\u0003\u00c0\u0003\u00c0\u0003\u00c0\u0003\u00c0\u0003", + "\u00c1\u0003\u00c1\u0003\u00c1\u0003\u00c1\u0003\u00c1\u0003\u00c1\u0003", + "\u00c1\u0003\u00c1\u0003\u00c1\u0003\u00c2\u0003\u00c2\u0003\u00c2\u0003", + "\u00c2\u0003\u00c2\u0003\u00c2\u0003\u00c2\u0003\u00c3\u0003\u00c3\u0003", + "\u00c3\u0003\u00c3\u0003\u00c3\u0003\u00c3\u0003\u00c3\u0003\u00c4\u0003", + "\u00c4\u0003\u00c4\u0003\u00c4\u0003\u00c4\u0003\u00c5\u0003\u00c5\u0003", + "\u00c5\u0003\u00c5\u0003\u00c5\u0003\u00c6\u0003\u00c6\u0003\u00c6\u0003", + "\u00c6\u0003\u00c6\u0003\u00c6\u0003\u00c6\u0003\u00c7\u0003\u00c7\u0003", + "\u00c7\u0003\u00c7\u0003\u00c7\u0003\u00c7\u0003\u00c7\u0003\u00c7\u0003", + "\u00c7\u0003\u00c8\u0003\u00c8\u0003\u00c8\u0003\u00c8\u0003\u00c8\u0003", + "\u00c8\u0003\u00c8\u0003\u00c8\u0003\u00c8\u0003\u00c8\u0003\u00c9\u0003", + "\u00c9\u0003\u00c9\u0003\u00c9\u0003\u00c9\u0003\u00ca\u0003\u00ca\u0003", + "\u00ca\u0003\u00ca\u0003\u00ca\u0003\u00ca\u0003\u00ca\u0003\u00cb\u0003", + "\u00cb\u0003\u00cb\u0003\u00cb\u0003\u00cb\u0003\u00cb\u0003\u00cc\u0003", + "\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003", + "\u00cc\u0003\u00cd\u0003\u00cd\u0003\u00cd\u0003\u00cd\u0003\u00cd\u0003", + "\u00cd\u0003\u00cd\u0003\u00cd\u0003\u00cd\u0003\u00cd\u0003\u00ce\u0003", + "\u00ce\u0003\u00ce\u0003\u00ce\u0003\u00ce\u0003\u00ce\u0003\u00ce\u0003", + "\u00ce\u0003\u00ce\u0003\u00ce\u0003\u00cf\u0003\u00cf\u0003\u00cf\u0003", + "\u00cf\u0003\u00cf\u0003\u00cf\u0003\u00cf\u0003\u00cf\u0003\u00d0\u0003", + "\u00d0\u0003\u00d0\u0003\u00d0\u0003\u00d0\u0003\u00d0\u0003\u00d0\u0003", + "\u00d0\u0003\u00d1\u0003\u00d1\u0003\u00d1\u0003\u00d1\u0003\u00d1\u0003", + "\u00d1\u0003\u00d1\u0003\u00d1\u0003\u00d1\u0003\u00d1\u0003\u00d2\u0003", + "\u00d2\u0003\u00d2\u0003\u00d2\u0003\u00d2\u0003\u00d2\u0003\u00d2\u0003", + "\u00d2\u0003\u00d2\u0003\u00d3\u0003\u00d3\u0003\u00d3\u0003\u00d3\u0003", + "\u00d3\u0003\u00d3\u0003\u00d3\u0003\u00d4\u0003\u00d4\u0003\u00d4\u0003", + "\u00d4\u0003\u00d4\u0003\u00d4\u0003\u00d5\u0003\u00d5\u0003\u00d5\u0003", + "\u00d5\u0003\u00d5\u0003\u00d5\u0003\u00d5\u0003\u00d5\u0003\u00d5\u0003", + "\u00d5\u0003\u00d6\u0003\u00d6\u0003\u00d6\u0003\u00d6\u0003\u00d6\u0003", + "\u00d6\u0003\u00d7\u0003\u00d7\u0003\u00d7\u0003\u00d7\u0003\u00d7\u0003", + "\u00d7\u0003\u00d7\u0003\u00d7\u0003\u00d8\u0003\u00d8\u0003\u00d8\u0003", + "\u00d8\u0003\u00d8\u0003\u00d8\u0003\u00d8\u0003\u00d8\u0003\u00d8\u0003", + "\u00d9\u0003\u00d9\u0003\u00d9\u0003\u00d9\u0003\u00d9\u0003\u00d9\u0003", + "\u00d9\u0003\u00d9\u0003\u00d9\u0003\u00d9\u0003\u00da\u0003\u00da\u0003", + "\u00da\u0003\u00da\u0003\u00da\u0003\u00da\u0003\u00da\u0003\u00db\u0003", + "\u00db\u0003\u00db\u0003\u00db\u0003\u00db\u0003\u00db\u0003\u00db\u0003", + "\u00db\u0003\u00dc\u0003\u00dc\u0003\u00dc\u0003\u00dc\u0003\u00dc\u0003", + "\u00dc\u0003\u00dc\u0003\u00dc\u0003\u00dd\u0003\u00dd\u0003\u00dd\u0003", + "\u00dd\u0003\u00dd\u0003\u00dd\u0003\u00dd\u0003\u00de\u0003\u00de\u0003", + "\u00de\u0003\u00de\u0003\u00de\u0003\u00df\u0003\u00df\u0003\u00df\u0003", + "\u00df\u0003\u00df\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003", + "\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e1\u0003", + "\u00e1\u0003\u00e1\u0003\u00e2\u0003\u00e2\u0003\u00e2\u0003\u00e2\u0003", + "\u00e2\u0003\u00e2\u0003\u00e2\u0003\u00e2\u0003\u00e2\u0003\u00e2\u0003", + "\u00e3\u0003\u00e3\u0003\u00e3\u0003\u00e3\u0003\u00e3\u0003\u00e3\u0003", + "\u00e3\u0003\u00e3\u0003\u00e3\u0003\u00e3\u0003\u00e4\u0003\u00e4\u0003", + "\u00e4\u0003\u00e4\u0003\u00e4\u0003\u00e4\u0003\u00e4\u0003\u00e4\u0003", + "\u00e4\u0003\u00e5\u0003\u00e5\u0003\u00e5\u0003\u00e5\u0003\u00e5\u0003", + "\u00e5\u0003\u00e5\u0003\u00e5\u0003\u00e5\u0003\u00e5\u0003\u00e6\u0003", + "\u00e6\u0003\u00e6\u0003\u00e6\u0003\u00e6\u0003\u00e6\u0003\u00e6\u0003", + "\u00e6\u0003\u00e6\u0003\u00e6\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e8\u0003\u00e8\u0003\u00e8\u0003", + "\u00e8\u0003\u00e8\u0003\u00e8\u0003\u00e8\u0003\u00e8\u0003\u00e9\u0003", + "\u00e9\u0003\u00e9\u0003\u00e9\u0003\u00e9\u0003\u00e9\u0003\u00e9\u0003", + "\u00e9\u0003\u00ea\u0003\u00ea\u0003\u00ea\u0003\u00ea\u0003\u00ea\u0003", + "\u00ea\u0003\u00ea\u0003\u00ea\u0003\u00ea\u0003\u00eb\u0003\u00eb\u0003", + "\u00eb\u0003\u00eb\u0003\u00eb\u0003\u00eb\u0003\u00eb\u0003\u00ec\u0003", + "\u00ec\u0003\u00ec\u0003\u00ec\u0003\u00ec\u0003\u00ec\u0003\u00ec\u0003", + "\u00ec\u0003\u00ec\u0003\u00ec\u0003\u00ec\u0003\u00ec\u0003\u00ed\u0003", + "\u00ed\u0003\u00ed\u0003\u00ed\u0003\u00ed\u0003\u00ed\u0003\u00ed\u0003", + "\u00ee\u0003\u00ee\u0003\u00ee\u0003\u00ee\u0003\u00ee\u0003\u00ee\u0003", + "\u00ee\u0003\u00ee\u0003\u00ef\u0003\u00ef\u0003\u00ef\u0003\u00ef\u0003", + "\u00ef\u0003\u00ef\u0003\u00ef\u0003\u00ef\u0003\u00f0\u0003\u00f0\u0003", + "\u00f0\u0003\u00f0\u0003\u00f0\u0003\u00f0\u0003\u00f0\u0003\u00f0\u0003", + "\u00f0\u0003\u00f0\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003", + "\u00f2\u0003\u00f2\u0003\u00f2\u0003\u00f2\u0003\u00f2\u0003\u00f2\u0003", + "\u00f3\u0003\u00f3\u0003\u00f3\u0003\u00f3\u0003\u00f3\u0003\u00f3\u0003", + "\u00f3\u0003\u00f3\u0003\u00f3\u0003\u00f4\u0003\u00f4\u0003\u00f4\u0003", + "\u00f4\u0003\u00f4\u0003\u00f4\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003", + "\u00f5\u0003\u00f5\u0003\u00f6\u0003\u00f6\u0003\u00f6\u0003\u00f6\u0003", + "\u00f6\u0003\u00f6\u0003\u00f6\u0003\u00f6\u0003\u00f6\u0003\u00f6\u0003", + "\u00f7\u0003\u00f7\u0003\u00f7\u0003\u00f7\u0003\u00f7\u0003\u00f7\u0003", + "\u00f8\u0003\u00f8\u0003\u00f8\u0003\u00f8\u0003\u00f8\u0003\u00f8\u0003", + "\u00f8\u0003\u00f9\u0003\u00f9\u0003\u00f9\u0003\u00f9\u0003\u00f9\u0003", + "\u00fa\u0003\u00fa\u0003\u00fa\u0003\u00fa\u0003\u00fa\u0003\u00fa\u0003", + "\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003", + "\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fc\u0003\u00fc\u0003\u00fc\u0003", + "\u00fc\u0003\u00fc\u0003\u00fd\u0003\u00fd\u0003\u00fd\u0003\u00fd\u0003", + "\u00fd\u0003\u00fd\u0003\u00fd\u0003\u00fd\u0003\u00fe\u0003\u00fe\u0003", + "\u00fe\u0003\u00fe\u0003\u00fe\u0003\u00fe\u0003\u00ff\u0003\u00ff\u0003", + "\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003", + "\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003\u0100\u0003", + "\u0100\u0003\u0100\u0003\u0100\u0003\u0100\u0003\u0100\u0003\u0100\u0003", + "\u0100\u0003\u0100\u0003\u0101\u0003\u0101\u0003\u0101\u0003\u0101\u0003", + "\u0101\u0003\u0101\u0003\u0101\u0003\u0102\u0003\u0102\u0003\u0102\u0003", + "\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003", + "\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003\u0104\u0003", + "\u0104\u0003\u0104\u0003\u0104\u0003\u0104\u0003\u0104\u0003\u0105\u0003", + "\u0105\u0003\u0105\u0003\u0105\u0003\u0105\u0003\u0106\u0003\u0106\u0003", + "\u0106\u0003\u0106\u0003\u0106\u0003\u0107\u0003\u0107\u0003\u0107\u0003", + "\u0107\u0003\u0107\u0003\u0107\u0003\u0108\u0003\u0108\u0003\u0108\u0003", + "\u0108\u0003\u0108\u0003\u0109\u0003\u0109\u0003\u0109\u0003\u010a\u0003", + "\u010a\u0003\u010a\u0003\u010a\u0003\u010a\u0003\u010a\u0003\u010a\u0003", + "\u010a\u0003\u010b\u0003\u010b\u0003\u010b\u0003\u010b\u0003\u010b\u0003", + "\u010b\u0003\u010b\u0003\u010c\u0003\u010c\u0003\u010c\u0003\u010c\u0003", + "\u010c\u0003\u010c\u0003\u010c\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010e\u0003\u010e\u0003\u010e\u0003", + "\u010e\u0003\u010e\u0003\u010e\u0003\u010e\u0003\u010f\u0003\u010f\u0003", + "\u010f\u0003\u0110\u0003\u0110\u0003\u0110\u0003\u0110\u0003\u0111\u0003", + "\u0111\u0003\u0111\u0003\u0111\u0003\u0111\u0003\u0112\u0003\u0112\u0003", + "\u0112\u0003\u0112\u0003\u0112\u0003\u0112\u0003\u0112\u0003\u0112\u0003", + "\u0112\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0114\u0003\u0114\u0003\u0114\u0003\u0114\u0003", + "\u0114\u0003\u0114\u0003\u0114\u0003\u0114\u0003\u0115\u0003\u0115\u0003", + "\u0115\u0003\u0115\u0003\u0115\u0003\u0115\u0003\u0116\u0003\u0116\u0003", + "\u0116\u0003\u0116\u0003\u0116\u0003\u0116\u0003\u0117\u0003\u0117\u0003", + "\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003\u0118\u0003", + "\u0118\u0003\u0118\u0003\u0118\u0003\u0118\u0003\u0118\u0003\u0118\u0003", + "\u0118\u0003\u0119\u0003\u0119\u0003\u0119\u0003\u0119\u0003\u0119\u0003", + "\u0119\u0003\u0119\u0003\u0119\u0003\u0119\u0003\u0119\u0003\u011a\u0003", + "\u011a\u0003\u011a\u0003\u011a\u0003\u011a\u0003\u011a\u0003\u011a\u0003", + "\u011a\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011c\u0003\u011c\u0003", + "\u011c\u0003\u011c\u0003\u011c\u0003\u011c\u0003\u011d\u0003\u011d\u0003", + "\u011d\u0003\u011d\u0003\u011d\u0003\u011d\u0003\u011d\u0003\u011d\u0003", + "\u011d\u0003\u011d\u0003\u011e\u0003\u011e\u0003\u011e\u0003\u011e\u0003", + "\u011e\u0003\u011e\u0003\u011e\u0003\u011e\u0003\u011f\u0003\u011f\u0003", + "\u011f\u0003\u011f\u0003\u011f\u0003\u011f\u0003\u011f\u0003\u011f\u0003", + "\u011f\u0003\u0120\u0003\u0120\u0003\u0120\u0003\u0120\u0003\u0120\u0003", + "\u0120\u0003\u0120\u0003\u0120\u0003\u0120\u0003\u0121\u0003\u0121\u0003", + "\u0121\u0003\u0121\u0003\u0121\u0003\u0121\u0003\u0122\u0003\u0122\u0003", + "\u0122\u0003\u0122\u0003\u0122\u0003\u0122\u0003\u0122\u0003\u0122\u0003", + "\u0122\u0003\u0122\u0003\u0122\u0003\u0123\u0003\u0123\u0003\u0123\u0003", + "\u0123\u0003\u0123\u0003\u0123\u0003\u0123\u0003\u0123\u0003\u0123\u0003", + "\u0123\u0003\u0123\u0003\u0124\u0003\u0124\u0003\u0124\u0003\u0124\u0003", + "\u0124\u0003\u0124\u0003\u0124\u0003\u0124\u0003\u0124\u0003\u0124\u0003", + "\u0125\u0003\u0125\u0003\u0125\u0003\u0125\u0003\u0125\u0003\u0125\u0003", + "\u0125\u0003\u0125\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126\u0003", + "\u0126\u0003\u0126\u0003\u0127\u0003\u0127\u0003\u0127\u0003\u0127\u0003", + "\u0127\u0003\u0127\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003", + "\u0128\u0003\u0129\u0003\u0129\u0003\u0129\u0003\u0129\u0003\u0129\u0003", + "\u0129\u0003\u0129\u0003\u0129\u0003\u0129\u0003\u012a\u0003\u012a\u0003", + "\u012a\u0003\u012a\u0003\u012a\u0003\u012a\u0003\u012a\u0003\u012a\u0003", + "\u012b\u0003\u012b\u0003\u012b\u0003\u012b\u0003\u012b\u0003\u012b\u0003", + "\u012b\u0003\u012b\u0003\u012b\u0003\u012b\u0003\u012c\u0003\u012c\u0003", + "\u012c\u0003\u012c\u0003\u012d\u0003\u012d\u0003\u012d\u0003\u012d\u0003", + "\u012d\u0003\u012d\u0003\u012d\u0003\u012d\u0003\u012e\u0003\u012e\u0003", + "\u012e\u0003\u012e\u0003\u012e\u0003\u012e\u0003\u012e\u0003\u012e\u0003", + "\u012f\u0003\u012f\u0003\u012f\u0003\u012f\u0003\u012f\u0003\u012f\u0003", + "\u012f\u0003\u012f\u0003\u012f\u0003\u0130\u0003\u0130\u0003\u0130\u0003", + "\u0130\u0003\u0130\u0003\u0130\u0003\u0130\u0003\u0130\u0003\u0131\u0003", + "\u0131\u0003\u0131\u0003\u0131\u0003\u0131\u0003\u0131\u0003\u0131\u0003", + "\u0132\u0003\u0132\u0003\u0132\u0003\u0132\u0003\u0132\u0003\u0132\u0003", + "\u0132\u0003\u0132\u0003\u0132\u0003\u0132\u0003\u0132\u0003\u0133\u0003", + "\u0133\u0003\u0133\u0003\u0133\u0003\u0133\u0003\u0133\u0003\u0133\u0003", + "\u0133\u0003\u0134\u0003\u0134\u0003\u0134\u0003\u0134\u0003\u0134\u0003", + "\u0134\u0003\u0134\u0003\u0134\u0003\u0135\u0003\u0135\u0003\u0135\u0003", + "\u0135\u0003\u0135\u0003\u0135\u0003\u0136\u0003\u0136\u0003\u0136\u0003", + "\u0136\u0003\u0136\u0003\u0136\u0003\u0136\u0003\u0136\u0003\u0137\u0003", + "\u0137\u0003\u0137\u0003\u0137\u0003\u0137\u0003\u0137\u0003\u0137\u0003", + "\u0137\u0003\u0137\u0003\u0138\u0003\u0138\u0003\u0138\u0003\u0138\u0003", + "\u0138\u0003\u0138\u0003\u0138\u0003\u0138\u0003\u0139\u0003\u0139\u0003", + "\u0139\u0003\u0139\u0003\u0139\u0003\u0139\u0003\u0139\u0003\u013a\u0003", + "\u013a\u0003\u013a\u0003\u013a\u0003\u013a\u0003\u013b\u0003\u013b\u0003", + "\u013b\u0003\u013b\u0003\u013b\u0003\u013b\u0003\u013b\u0003\u013b\u0003", + "\u013b\u0003\u013c\u0003\u013c\u0003\u013c\u0003\u013c\u0003\u013c\u0003", + "\u013d\u0003\u013d\u0003\u013d\u0003\u013d\u0003\u013d\u0003\u013e\u0003", + "\u013e\u0003\u013e\u0003\u013e\u0003\u013e\u0003\u013e\u0003\u013e\u0003", + "\u013e\u0003\u013e\u0003\u013e\u0003\u013f\u0003\u013f\u0003\u013f\u0003", + "\u013f\u0003\u013f\u0003\u013f\u0003\u013f\u0003\u0140\u0003\u0140\u0003", + "\u0140\u0003\u0140\u0003\u0140\u0003\u0140\u0003\u0140\u0003\u0141\u0003", + "\u0141\u0003\u0141\u0003\u0141\u0003\u0141\u0003\u0141\u0003\u0141\u0003", + "\u0142\u0003\u0142\u0003\u0142\u0003\u0142\u0003\u0142\u0003\u0142\u0003", + "\u0142\u0003\u0143\u0003\u0143\u0003\u0143\u0003\u0143\u0003\u0143\u0003", + "\u0143\u0003\u0143\u0003\u0143\u0003\u0143\u0003\u0144\u0003\u0144\u0003", + "\u0144\u0003\u0144\u0003\u0144\u0003\u0144\u0003\u0144\u0003\u0144\u0003", + "\u0144\u0003\u0145\u0003\u0145\u0003\u0145\u0003\u0145\u0003\u0145\u0003", + "\u0145\u0003\u0145\u0003\u0145\u0003\u0145\u0003\u0145\u0003\u0146\u0003", + "\u0146\u0003\u0146\u0003\u0146\u0003\u0146\u0003\u0146\u0003\u0146\u0003", + "\u0146\u0003\u0146\u0003\u0146\u0003\u0146\u0003\u0146\u0003\u0146\u0003", + "\u0147\u0003\u0147\u0003\u0147\u0003\u0147\u0003\u0147\u0003\u0147\u0003", + "\u0147\u0003\u0148\u0003\u0148\u0003\u0148\u0003\u0148\u0003\u0148\u0003", + "\u0148\u0003\u0148\u0003\u0148\u0003\u0149\u0003\u0149\u0003\u0149\u0003", + "\u0149\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003", + "\u014a\u0003\u014b\u0003\u014b\u0003\u014b\u0003\u014b\u0003\u014b\u0003", + "\u014c\u0003\u014c\u0003\u014c\u0003\u014c\u0003\u014c\u0003\u014c\u0003", + "\u014c\u0003\u014d\u0003\u014d\u0003\u014d\u0003\u014d\u0003\u014d\u0003", + "\u014d\u0003\u014d\u0003\u014d\u0003\u014d\u0003\u014e\u0003\u014e\u0003", + "\u014e\u0003\u014e\u0003\u014e\u0003\u014e\u0003\u014e\u0003\u014f\u0003", + "\u014f\u0003\u014f\u0003\u014f\u0003\u014f\u0003\u014f\u0003\u014f\u0003", + "\u014f\u0003\u014f\u0003\u014f\u0003\u014f\u0003\u0150\u0003\u0150\u0003", + "\u0150\u0003\u0150\u0003\u0150\u0003\u0150\u0003\u0151\u0003\u0151\u0003", + "\u0151\u0003\u0151\u0003\u0151\u0003\u0151\u0003\u0151\u0003\u0151\u0003", + "\u0151\u0003\u0151\u0003\u0152\u0003\u0152\u0003\u0152\u0003\u0152\u0003", + "\u0152\u0003\u0152\u0003\u0152\u0003\u0152\u0003\u0152\u0003\u0152\u0003", + "\u0152\u0003\u0153\u0003\u0153\u0003\u0153\u0003\u0153\u0003\u0153\u0003", + "\u0153\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003", + "\u0154\u0003\u0154\u0003\u0155\u0003\u0155\u0003\u0155\u0003\u0155\u0003", + "\u0155\u0003\u0155\u0003\u0155\u0003\u0155\u0003\u0156\u0003\u0156\u0003", + "\u0156\u0003\u0156\u0003\u0156\u0003\u0156\u0003\u0156\u0003\u0157\u0003", + "\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003\u0158\u0003", + "\u0158\u0003\u0158\u0003\u0158\u0003\u0158\u0003\u0158\u0003\u0159\u0003", + "\u0159\u0003\u0159\u0003\u0159\u0003\u0159\u0003\u0159\u0003\u0159\u0003", + "\u015a\u0003\u015a\u0003\u015a\u0003\u015a\u0003\u015a\u0003\u015a\u0003", + "\u015a\u0003\u015b\u0003\u015b\u0003\u015b\u0003\u015b\u0003\u015b\u0003", + "\u015b\u0003\u015b\u0003\u015b\u0003\u015b\u0003\u015b\u0003\u015b\u0003", + "\u015c\u0003\u015c\u0003\u015c\u0003\u015c\u0003\u015c\u0003\u015d\u0003", + "\u015d\u0003\u015d\u0003\u015d\u0003\u015d\u0003\u015d\u0003\u015d\u0003", + "\u015d\u0003\u015d\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003", + "\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003", + "\u015f\u0003\u015f\u0003\u015f\u0003\u015f\u0003\u015f\u0003\u0160\u0003", + "\u0160\u0003\u0160\u0003\u0160\u0003\u0160\u0003\u0160\u0003\u0160\u0003", + "\u0160\u0003\u0160\u0003\u0160\u0003\u0160\u0003\u0160\u0003\u0161\u0003", + "\u0161\u0003\u0161\u0003\u0161\u0003\u0161\u0003\u0161\u0003\u0161\u0003", + "\u0161\u0003\u0162\u0003\u0162\u0003\u0162\u0003\u0162\u0003\u0162\u0003", + "\u0162\u0003\u0162\u0003\u0162\u0003\u0162\u0003\u0163\u0003\u0163\u0003", + "\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003", + "\u0164\u0003\u0164\u0003\u0164\u0003\u0164\u0003\u0164\u0003\u0165\u0003", + "\u0165\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0166\u0003", + "\u0166\u0003\u0166\u0003\u0166\u0003\u0166\u0003\u0166\u0003\u0166\u0003", + "\u0166\u0003\u0166\u0003\u0166\u0003\u0167\u0003\u0167\u0003\u0167\u0003", + "\u0167\u0003\u0167\u0003\u0167\u0003\u0167\u0003\u0167\u0003\u0167\u0003", + "\u0167\u0003\u0167\u0003\u0167\u0003\u0168\u0003\u0168\u0003\u0168\u0003", + "\u0168\u0003\u0168\u0003\u0168\u0003\u0168\u0003\u0168\u0003\u0168\u0003", + "\u0168\u0003\u0168\u0003\u0168\u0003\u0169\u0003\u0169\u0003\u0169\u0003", + "\u0169\u0003\u0169\u0003\u0169\u0003\u0169\u0003\u0169\u0003\u016a\u0003", + "\u016a\u0003\u016a\u0003\u016a\u0003\u016a\u0003\u016a\u0003\u016a\u0003", + "\u016a\u0003\u016a\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016c\u0003", + "\u016c\u0003\u016c\u0003\u016c\u0003\u016c\u0003\u016c\u0003\u016d\u0003", + "\u016d\u0003\u016d\u0003\u016d\u0003\u016d\u0003\u016d\u0003\u016d\u0003", + "\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003", + "\u016e\u0003\u016f\u0003\u016f\u0003\u016f\u0003\u016f\u0003\u016f\u0003", + "\u016f\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003", + "\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0171\u0003\u0171\u0003", + "\u0171\u0003\u0171\u0003\u0171\u0003\u0171\u0003\u0171\u0003\u0171\u0003", + "\u0171\u0003\u0171\u0003\u0172\u0003\u0172\u0003\u0172\u0003\u0172\u0003", + "\u0172\u0003\u0172\u0003\u0172\u0003\u0172\u0003\u0173\u0003\u0173\u0003", + "\u0173\u0003\u0173\u0003\u0173\u0003\u0173\u0003\u0173\u0003\u0173\u0003", + "\u0174\u0003\u0174\u0003\u0174\u0003\u0174\u0003\u0174\u0003\u0175\u0003", + "\u0175\u0003\u0175\u0003\u0175\u0003\u0175\u0003\u0175\u0003\u0175\u0003", + "\u0175\u0003\u0175\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0177\u0003\u0177\u0003\u0177\u0003\u0177\u0003\u0177\u0003", + "\u0177\u0003\u0177\u0003\u0177\u0003\u0178\u0003\u0178\u0003\u0178\u0003", + "\u0178\u0003\u0178\u0003\u0179\u0003\u0179\u0003\u0179\u0003\u0179\u0003", + "\u0179\u0003\u0179\u0003\u0179\u0003\u0179\u0003\u017a\u0003\u017a\u0003", + "\u017a\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017b\u0003\u017b\u0003", + "\u017b\u0003\u017b\u0003\u017c\u0003\u017c\u0003\u017c\u0003\u017c\u0003", + "\u017c\u0003\u017d\u0003\u017d\u0003\u017d\u0003\u017d\u0003\u017e\u0003", + "\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017f\u0003\u017f\u0003", + "\u017f\u0003\u017f\u0003\u017f\u0003\u017f\u0003\u017f\u0003\u017f\u0003", + "\u0180\u0003\u0180\u0003\u0180\u0003\u0180\u0003\u0180\u0003\u0180\u0003", + "\u0180\u0003\u0181\u0003\u0181\u0003\u0181\u0003\u0181\u0003\u0182\u0003", + "\u0182\u0003\u0182\u0003\u0182\u0003\u0182\u0003\u0182\u0003\u0182\u0003", + "\u0182\u0003\u0183\u0003\u0183\u0003\u0183\u0003\u0183\u0003\u0183\u0003", + "\u0184\u0003\u0184\u0003\u0184\u0003\u0184\u0003\u0184\u0003\u0184\u0003", + "\u0184\u0003\u0184\u0003\u0184\u0003\u0184\u0003\u0185\u0003\u0185\u0003", + "\u0185\u0003\u0185\u0003\u0185\u0003\u0185\u0003\u0185\u0003\u0185\u0003", + "\u0185\u0003\u0186\u0003\u0186\u0003\u0186\u0003\u0186\u0003\u0187\u0003", + "\u0187\u0003\u0187\u0003\u0187\u0003\u0187\u0003\u0187\u0003\u0187\u0003", + "\u0187\u0003\u0188\u0003\u0188\u0003\u0188\u0003\u0188\u0003\u0188\u0003", + "\u0188\u0003\u0188\u0003\u0189\u0003\u0189\u0003\u0189\u0003\u0189\u0003", + "\u0189\u0003\u0189\u0003\u0189\u0003\u0189\u0003\u018a\u0003\u018a\u0003", + "\u018a\u0003\u018a\u0003\u018a\u0003\u018a\u0003\u018b\u0003\u018b\u0003", + "\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003", + "\u018b\u0003\u018c\u0003\u018c\u0003\u018c\u0003\u018c\u0003\u018c\u0003", + "\u018c\u0003\u018d\u0003\u018d\u0003\u018d\u0003\u018d\u0003\u018e\u0003", + "\u018e\u0003\u018e\u0003\u018e\u0003\u018e\u0003\u018e\u0003\u018e\u0003", + "\u018e\u0003\u018f\u0003\u018f\u0003\u018f\u0003\u018f\u0003\u018f\u0003", + "\u018f\u0003\u018f\u0003\u018f\u0003\u018f\u0003\u0190\u0003\u0190\u0003", + "\u0190\u0003\u0190\u0003\u0190\u0003\u0190\u0003\u0191\u0003\u0191\u0003", + "\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0003", + "\u0191\u0003\u0192\u0003\u0192\u0003\u0192\u0003\u0192\u0003\u0192\u0003", + "\u0192\u0003\u0193\u0003\u0193\u0003\u0193\u0003\u0193\u0003\u0193\u0003", + "\u0194\u0003\u0194\u0003\u0194\u0003\u0194\u0003\u0194\u0003\u0194\u0003", + "\u0194\u0003\u0195\u0003\u0195\u0003\u0195\u0003\u0195\u0003\u0195\u0003", + "\u0195\u0003\u0195\u0003\u0195\u0003\u0196\u0003\u0196\u0003\u0196\u0003", + "\u0196\u0003\u0196\u0003\u0196\u0003\u0196\u0003\u0196\u0003\u0197\u0003", + "\u0197\u0003\u0197\u0003\u0197\u0003\u0197\u0003\u0197\u0003\u0197\u0003", + "\u0197\u0003\u0197\u0003\u0198\u0003\u0198\u0003\u0198\u0003\u0198\u0003", + "\u0198\u0003\u0198\u0003\u0198\u0003\u0198\u0003\u0198\u0003\u0198\u0003", + "\u0199\u0003\u0199\u0003\u0199\u0003\u0199\u0003\u0199\u0003\u019a\u0003", + "\u019a\u0003\u019a\u0003\u019a\u0003\u019b\u0003\u019b\u0003\u019b\u0003", + "\u019b\u0003\u019b\u0003\u019b\u0003\u019c\u0003\u019c\u0003\u019c\u0003", + "\u019c\u0003\u019c\u0003\u019c\u0003\u019c\u0003\u019c\u0003\u019c\u0003", + "\u019d\u0003\u019d\u0003\u019d\u0003\u019d\u0003\u019d\u0003\u019d\u0003", + "\u019d\u0003\u019d\u0003\u019d\u0003\u019d\u0003\u019e\u0003\u019e\u0003", + "\u019e\u0003\u019e\u0003\u019e\u0003\u019f\u0003\u019f\u0003\u019f\u0003", + "\u019f\u0003\u019f\u0003\u019f\u0003\u019f\u0003\u019f\u0003\u019f\u0003", + "\u019f\u0003\u01a0\u0003\u01a0\u0003\u01a0\u0003\u01a0\u0003\u01a0\u0003", + "\u01a0\u0003\u01a1\u0003\u01a1\u0003\u01a1\u0003\u01a1\u0003\u01a1\u0003", + "\u01a2\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0003", + "\u01a2\u0003\u01a3\u0003\u01a3\u0003\u01a3\u0003\u01a3\u0003\u01a3\u0003", + "\u01a3\u0003\u01a3\u0003\u01a3\u0003\u01a4\u0003\u01a4\u0003\u01a4\u0003", + "\u01a4\u0003\u01a4\u0003\u01a4\u0003\u01a4\u0003\u01a4\u0003\u01a4\u0003", + "\u01a4\u0003\u01a4\u0003\u01a4\u0003\u01a4\u0003\u01a4\u0003\u01a5\u0003", + "\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003", + "\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a6\u0003\u01a6\u0003\u01a6\u0003", + "\u01a6\u0003\u01a6\u0003\u01a6\u0003\u01a6\u0003\u01a6\u0003\u01a6\u0003", + "\u01a6\u0003\u01a6\u0003\u01a7\u0003\u01a7\u0003\u01a7\u0003\u01a7\u0003", + "\u01a7\u0003\u01a7\u0003\u01a7\u0003\u01a7\u0003\u01a7\u0003\u01a7\u0003", + "\u01a8\u0003\u01a8\u0003\u01a8\u0003\u01a8\u0003\u01a8\u0003\u01a8\u0003", + "\u01a8\u0003\u01a8\u0003\u01a8\u0003\u01a8\u0003\u01a9\u0003\u01a9\u0003", + "\u01a9\u0003\u01a9\u0003\u01a9\u0003\u01a9\u0003\u01a9\u0003\u01a9\u0003", + "\u01a9\u0003\u01aa\u0003\u01aa\u0003\u01aa\u0003\u01aa\u0003\u01aa\u0003", + "\u01aa\u0003\u01ab\u0003\u01ab\u0003\u01ab\u0003\u01ab\u0003\u01ab\u0003", + "\u01ab\u0003\u01ab\u0003\u01ab\u0003\u01ac\u0003\u01ac\u0003\u01ac\u0003", + "\u01ac\u0003\u01ac\u0003\u01ac\u0003\u01ac\u0003\u01ac\u0003\u01ac\u0003", + "\u01ac\u0003\u01ac\u0003\u01ac\u0003\u01ac\u0003\u01ad\u0003\u01ad\u0003", + "\u01ad\u0003\u01ad\u0003\u01ad\u0003\u01ae\u0003\u01ae\u0003\u01ae\u0003", + "\u01ae\u0003\u01ae\u0003\u01ae\u0003\u01ae\u0003\u01ae\u0003\u01af\u0003", + "\u01af\u0003\u01af\u0003\u01af\u0003\u01af\u0003\u01af\u0003\u01af\u0003", + "\u01b0\u0003\u01b0\u0003\u01b0\u0003\u01b0\u0003\u01b0\u0003\u01b0\u0003", + "\u01b0\u0003\u01b1\u0003\u01b1\u0003\u01b1\u0003\u01b1\u0003\u01b1\u0003", + "\u01b1\u0003\u01b1\u0003\u01b1\u0003\u01b1\u0003\u01b1\u0003\u01b1\u0003", + "\u01b2\u0003\u01b2\u0003\u01b2\u0003\u01b2\u0003\u01b2\u0003\u01b2\u0003", + "\u01b2\u0003\u01b2\u0003\u01b2\u0003\u01b2\u0003\u01b3\u0003\u01b3\u0003", + "\u01b3\u0003\u01b3\u0003\u01b3\u0003\u01b3\u0003\u01b3\u0003\u01b4\u0003", + "\u01b4\u0003\u01b4\u0003\u01b4\u0003\u01b4\u0003\u01b4\u0003\u01b4\u0003", + "\u01b5\u0003\u01b5\u0003\u01b5\u0003\u01b5\u0003\u01b5\u0003\u01b5\u0003", + "\u01b5\u0003\u01b5\u0003\u01b6\u0003\u01b6\u0003\u01b6\u0003\u01b6\u0003", + "\u01b6\u0003\u01b6\u0003\u01b6\u0003\u01b6\u0003\u01b7\u0003\u01b7\u0003", + "\u01b7\u0003\u01b7\u0003\u01b7\u0003\u01b7\u0003\u01b7\u0003\u01b7\u0003", + "\u01b7\u0003\u01b7\u0003\u01b8\u0003\u01b8\u0003\u01b8\u0003\u01b8\u0003", + "\u01b8\u0003\u01b8\u0003\u01b8\u0003\u01b9\u0003\u01b9\u0003\u01b9\u0003", + "\u01b9\u0003\u01b9\u0003\u01b9\u0003\u01b9\u0003\u01ba\u0003\u01ba\u0003", + "\u01ba\u0003\u01ba\u0003\u01ba\u0003\u01ba\u0003\u01ba\u0003\u01bb\u0003", + "\u01bb\u0003\u01bb\u0003\u01bb\u0003\u01bb\u0003\u01bb\u0003\u01bb\u0003", + "\u01bb\u0003\u01bb\u0003\u01bb\u0003\u01bb\u0003\u01bb\u0003\u01bc\u0003", + "\u01bc\u0003\u01bc\u0003\u01bc\u0003\u01bd\u0003\u01bd\u0003\u01bd\u0003", + "\u01bd\u0003\u01be\u0003\u01be\u0003\u01be\u0003\u01be\u0003\u01be\u0003", + "\u01be\u0003\u01bf\u0003\u01bf\u0003\u01bf\u0003\u01bf\u0003\u01bf\u0003", + "\u01bf\u0003\u01bf\u0003\u01bf\u0003\u01bf\u0003\u01bf\u0003\u01bf\u0003", + "\u01bf\u0003\u01bf\u0003\u01c0\u0003\u01c0\u0003\u01c0\u0003\u01c0\u0003", + "\u01c0\u0003\u01c0\u0003\u01c0\u0003\u01c0\u0003\u01c0\u0003\u01c0\u0003", + "\u01c0\u0003\u01c0\u0003\u01c1\u0003\u01c1\u0003\u01c1\u0003\u01c1\u0003", + "\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c3\u0003\u01c3\u0003", + "\u01c3\u0003\u01c3\u0003\u01c3\u0003\u01c3\u0003\u01c3\u0003\u01c3\u0003", + "\u01c3\u0003\u01c4\u0003\u01c4\u0003\u01c4\u0003\u01c4\u0003\u01c4\u0003", + "\u01c4\u0003\u01c4\u0003\u01c4\u0003\u01c5\u0003\u01c5\u0003\u01c5\u0003", + "\u01c5\u0003\u01c5\u0003\u01c5\u0003\u01c5\u0003\u01c5\u0003\u01c5\u0003", + "\u01c5\u0003\u01c5\u0003\u01c6\u0003\u01c6\u0003\u01c6\u0003\u01c6\u0003", + "\u01c6\u0003\u01c6\u0003\u01c7\u0003\u01c7\u0003\u01c7\u0003\u01c7\u0003", + "\u01c7\u0003\u01c7\u0003\u01c7\u0003\u01c7\u0003\u01c8\u0003\u01c8\u0003", + "\u01c8\u0003\u01c8\u0003\u01c8\u0003\u01c8\u0003\u01c8\u0003\u01c8\u0003", + "\u01c8\u0003\u01c9\u0003\u01c9\u0003\u01c9\u0003\u01c9\u0003\u01ca\u0003", + "\u01ca\u0003\u01ca\u0003\u01ca\u0003\u01ca\u0003\u01ca\u0003\u01ca\u0003", + "\u01ca\u0003\u01cb\u0003\u01cb\u0003\u01cb\u0003\u01cb\u0003\u01cb\u0003", + "\u01cb\u0003\u01cb\u0003\u01cb\u0003\u01cb\u0003\u01cb\u0003\u01cb\u0003", + "\u01cc\u0003\u01cc\u0003\u01cc\u0003\u01cc\u0003\u01cc\u0003\u01cc\u0003", + "\u01cc\u0003\u01cc\u0003\u01cc\u0003\u01cd\u0003\u01cd\u0003\u01cd\u0003", + "\u01cd\u0003\u01cd\u0003\u01ce\u0003\u01ce\u0003\u01ce\u0003\u01ce\u0003", + "\u01ce\u0003\u01ce\u0003\u01ce\u0003\u01cf\u0003\u01cf\u0003\u01cf\u0003", + "\u01cf\u0003\u01cf\u0003\u01d0\u0003\u01d0\u0003\u01d0\u0003\u01d0\u0003", + "\u01d0\u0003\u01d0\u0003\u01d0\u0003\u01d1\u0003\u01d1\u0003\u01d1\u0003", + "\u01d1\u0003\u01d1\u0003\u01d2\u0003\u01d2\u0003\u01d2\u0003\u01d2\u0003", + "\u01d2\u0003\u01d2\u0003\u01d2\u0003\u01d2\u0003\u01d2\u0003\u01d3\u0003", + "\u01d3\u0003\u01d3\u0003\u01d3\u0003\u01d3\u0003\u01d4\u0003\u01d4\u0003", + "\u01d4\u0003\u01d4\u0003\u01d4\u0003\u01d4\u0003\u01d4\u0003\u01d4\u0003", + "\u01d4\u0003\u01d4\u0003\u01d4\u0003\u01d4\u0003\u01d5\u0003\u01d5\u0003", + "\u01d5\u0003\u01d5\u0003\u01d5\u0003\u01d5\u0003\u01d5\u0003\u01d5\u0003", + "\u01d5\u0003\u01d5\u0003\u01d5\u0003\u01d6\u0003\u01d6\u0003\u01d6\u0003", + "\u01d6\u0003\u01d6\u0003\u01d6\u0003\u01d6\u0003\u01d6\u0003\u01d6\u0003", + "\u01d7\u0003\u01d7\u0003\u01d7\u0003\u01d7\u0003\u01d7\u0003\u01d7\u0003", + "\u01d7\u0003\u01d7\u0003\u01d8\u0003\u01d8\u0003\u01d8\u0003\u01d8\u0003", + "\u01d8\u0003\u01d8\u0003\u01d8\u0003\u01d8\u0003\u01d8\u0003\u01d8\u0003", + "\u01d8\u0003\u01d8\u0003\u01d8\u0003\u01d8\u0003\u01d9\u0003\u01d9\u0003", + "\u01d9\u0003\u01d9\u0003\u01d9\u0003\u01d9\u0003\u01d9\u0003\u01d9\u0003", + "\u01da\u0003\u01da\u0003\u01da\u0003\u01da\u0003\u01da\u0003\u01da\u0003", + "\u01da\u0003\u01da\u0003\u01da\u0003\u01da\u0003\u01da\u0003\u01db\u0003", + "\u01db\u0003\u01db\u0003\u01db\u0003\u01db\u0003\u01db\u0003\u01db\u0003", + "\u01dc\u0003\u01dc\u0003\u01dc\u0003\u01dc\u0003\u01dc\u0003\u01dc\u0003", + "\u01dc\u0003\u01dd\u0003\u01dd\u0003\u01dd\u0003\u01dd\u0003\u01dd\u0003", + "\u01dd\u0003\u01dd\u0003\u01de\u0003\u01de\u0003\u01de\u0003\u01de\u0003", + "\u01de\u0003\u01de\u0003\u01de\u0003\u01df\u0003\u01df\u0003\u01df\u0003", + "\u01df\u0003\u01e0\u0003\u01e0\u0003\u01e0\u0003\u01e0\u0003\u01e1\u0003", + "\u01e1\u0003\u01e1\u0003\u01e1\u0003\u01e1\u0003\u01e2\u0003\u01e2\u0003", + "\u01e2\u0003\u01e2\u0003\u01e2\u0003\u01e3\u0003\u01e3\u0003\u01e3\u0003", + "\u01e3\u0003\u01e3\u0003\u01e3\u0003\u01e3\u0003\u01e3\u0003\u01e4\u0003", + "\u01e4\u0003\u01e4\u0003\u01e4\u0003\u01e4\u0003\u01e4\u0003\u01e5\u0003", + "\u01e5\u0003\u01e5\u0003\u01e5\u0003\u01e5\u0003\u01e5\u0003\u01e5\u0003", + "\u01e5\u0003\u01e5\u0003\u01e5\u0003\u01e6\u0003\u01e6\u0003\u01e6\u0003", + "\u01e6\u0003\u01e6\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003", + "\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003", + "\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003", + "\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e8\u0003\u01e8\u0003", + "\u01e8\u0003\u01e8\u0003\u01e8\u0003\u01e8\u0003\u01e8\u0003\u01e8\u0003", + "\u01e8\u0003\u01e8\u0003\u01e8\u0003\u01e8\u0003\u01e8\u0003\u01e8\u0003", + "\u01e8\u0003\u01e8\u0003\u01e8\u0003\u01e8\u0003\u01e9\u0003\u01e9\u0003", + "\u01e9\u0003\u01e9\u0003\u01e9\u0003\u01e9\u0003\u01ea\u0003\u01ea\u0003", + "\u01ea\u0003\u01ea\u0003\u01ea\u0003\u01ea\u0003\u01ea\u0003\u01ea\u0003", + "\u01ea\u0003\u01ea\u0003\u01ea\u0003\u01ea\u0003\u01ea\u0003\u01eb\u0003", + "\u01eb\u0003\u01eb\u0003\u01eb\u0003\u01eb\u0003\u01eb\u0003\u01eb\u0003", + "\u01eb\u0003\u01eb\u0003\u01eb\u0003\u01eb\u0003\u01ec\u0003\u01ec\u0003", + "\u01ec\u0003\u01ec\u0003\u01ec\u0003\u01ec\u0003\u01ed\u0003\u01ed\u0003", + "\u01ed\u0003\u01ed\u0003\u01ed\u0003\u01ed\u0003\u01ed\u0003\u01ed\u0003", + "\u01ed\u0003\u01ee\u0003\u01ee\u0003\u01ee\u0003\u01ee\u0003\u01ee\u0003", + "\u01ee\u0003\u01ee\u0003\u01ee\u0003\u01ef\u0003\u01ef\u0003\u01ef\u0003", + "\u01ef\u0003\u01f0\u0003\u01f0\u0003\u01f0\u0003\u01f0\u0003\u01f0\u0003", + "\u01f0\u0003\u01f0\u0003\u01f0\u0003\u01f0\u0003\u01f0\u0003\u01f0\u0003", + "\u01f0\u0003\u01f1\u0003\u01f1\u0003\u01f1\u0003\u01f1\u0003\u01f1\u0003", + "\u01f1\u0003\u01f1\u0003\u01f1\u0003\u01f2\u0003\u01f2\u0003\u01f2\u0003", + "\u01f2\u0003\u01f2\u0003\u01f2\u0003\u01f3\u0003\u01f3\u0003\u01f3\u0003", + "\u01f3\u0003\u01f3\u0003\u01f3\u0003\u01f4\u0003\u01f4\u0003\u01f4\u0003", + "\u01f4\u0003\u01f4\u0003\u01f4\u0003\u01f4\u0003\u01f4\u0003\u01f5\u0003", + "\u01f5\u0003\u01f5\u0003\u01f5\u0003\u01f5\u0003\u01f5\u0003\u01f5\u0003", + "\u01f5\u0003\u01f6\u0003\u01f6\u0003\u01f6\u0003\u01f6\u0003\u01f6\u0003", + "\u01f6\u0003\u01f7\u0003\u01f7\u0003\u01f7\u0003\u01f7\u0003\u01f7\u0003", + "\u01f8\u0003\u01f8\u0003\u01f8\u0003\u01f8\u0003\u01f8\u0003\u01f8\u0003", + "\u01f8\u0003\u01f9\u0003\u01f9\u0003\u01f9\u0003\u01f9\u0003\u01f9\u0003", + "\u01f9\u0003\u01fa\u0003\u01fa\u0003\u01fa\u0003\u01fa\u0003\u01fa\u0003", + "\u01fa\u0003\u01fb\u0003\u01fb\u0003\u01fb\u0003\u01fb\u0003\u01fb\u0003", + "\u01fb\u0003\u01fb\u0003\u01fb\u0003\u01fb\u0003\u01fc\u0003\u01fc\u0003", + "\u01fc\u0003\u01fc\u0003\u01fc\u0003\u01fc\u0003\u01fd\u0003\u01fd\u0003", + "\u01fd\u0003\u01fd\u0003\u01fe\u0003\u01fe\u0003\u01fe\u0003\u01fe\u0003", + "\u01fe\u0003\u01ff\u0003\u01ff\u0003\u01ff\u0003\u01ff\u0003\u01ff\u0003", + "\u01ff\u0003\u01ff\u0003\u0200\u0003\u0200\u0003\u0200\u0003\u0200\u0003", + "\u0200\u0003\u0200\u0003\u0200\u0003\u0200\u0003\u0201\u0003\u0201\u0003", + "\u0201\u0003\u0201\u0003\u0201\u0003\u0201\u0003\u0201\u0003\u0201\u0003", + "\u0201\u0003\u0201\u0003\u0202\u0003\u0202\u0003\u0202\u0003\u0202\u0003", + "\u0202\u0003\u0202\u0003\u0202\u0003\u0203\u0003\u0203\u0003\u0203\u0003", + "\u0203\u0003\u0203\u0003\u0204\u0003\u0204\u0003\u0204\u0003\u0204\u0003", + "\u0204\u0003\u0205\u0003\u0205\u0007\u0205\u134a\n\u0205\f\u0205\u000e", + "\u0205\u134d\u000b\u0205\u0003\u0206\u0003\u0206\u0003\u0206\u0003\u0206", + "\u0003\u0206\u0003\u0206\u0005\u0206\u1355\n\u0206\u0003\u0207\u0003", + "\u0207\u0005\u0207\u1359\n\u0207\u0003\u0208\u0003\u0208\u0005\u0208", + "\u135d\n\u0208\u0003\u0209\u0003\u0209\u0003\u0209\u0003\u020a\u0003", + "\u020a\u0003\u020a\u0003\u020a\u0007\u020a\u1366\n\u020a\f\u020a\u000e", + "\u020a\u1369\u000b\u020a\u0003\u020b\u0003\u020b\u0003\u020b\u0003\u020c", + "\u0003\u020c\u0003\u020c\u0003\u020c\u0007\u020c\u1372\n\u020c\f\u020c", + "\u000e\u020c\u1375\u000b\u020c\u0003\u020d\u0003\u020d\u0003\u020d\u0003", + "\u020d\u0003\u020e\u0003\u020e\u0003\u020e\u0003\u020e\u0003\u020f\u0003", + "\u020f\u0003\u020f\u0003\u020f\u0003\u0210\u0003\u0210\u0003\u0210\u0003", + "\u0210\u0003\u0211\u0003\u0211\u0003\u0211\u0003\u0212\u0003\u0212\u0003", + "\u0212\u0003\u0212\u0007\u0212\u138e\n\u0212\f\u0212\u000e\u0212\u1391", + "\u000b\u0212\u0003\u0213\u0003\u0213\u0003\u0213\u0003\u0213\u0003\u0213", + "\u0003\u0213\u0003\u0214\u0003\u0214\u0003\u0214\u0003\u0215\u0003\u0215", + "\u0003\u0215\u0003\u0215\u0003\u0216\u0003\u0216\u0005\u0216\u13a2\n", + "\u0216\u0003\u0216\u0003\u0216\u0003\u0216\u0003\u0216\u0003\u0216\u0003", + "\u0217\u0003\u0217\u0007\u0217\u13ab\n\u0217\f\u0217\u000e\u0217\u13ae", + "\u000b\u0217\u0003\u0218\u0003\u0218\u0003\u0218\u0003\u0219\u0003\u0219", + "\u0003\u0219\u0007\u0219\u13b6\n\u0219\f\u0219\u000e\u0219\u13b9\u000b", + "\u0219\u0003\u021a\u0003\u021a\u0003\u021a\u0003\u021b\u0003\u021b\u0003", + "\u021b\u0003\u021c\u0003\u021c\u0003\u021c\u0003\u021d\u0003\u021d\u0003", + "\u021d\u0007\u021d\u13c7\n\u021d\f\u021d\u000e\u021d\u13ca\u000b\u021d", + "\u0003\u021e\u0003\u021e\u0003\u021e\u0003\u021f\u0003\u021f\u0003\u021f", + "\u0003\u0220\u0003\u0220\u0003\u0221\u0003\u0221\u0003\u0221\u0003\u0221", + "\u0003\u0221\u0003\u0221\u0003\u0222\u0003\u0222\u0003\u0222\u0005\u0222", + "\u13dd\n\u0222\u0003\u0222\u0003\u0222\u0005\u0222\u13e1\n\u0222\u0003", + "\u0222\u0005\u0222\u13e4\n\u0222\u0003\u0222\u0003\u0222\u0003\u0222", + "\u0003\u0222\u0005\u0222\u13ea\n\u0222\u0003\u0222\u0005\u0222\u13ed", + "\n\u0222\u0003\u0222\u0003\u0222\u0003\u0222\u0005\u0222\u13f2\n\u0222", + "\u0003\u0222\u0003\u0222\u0005\u0222\u13f6\n\u0222\u0003\u0223\u0006", + "\u0223\u13f9\n\u0223\r\u0223\u000e\u0223\u13fa\u0003\u0224\u0003\u0224", + "\u0003\u0224\u0007\u0224\u1400\n\u0224\f\u0224\u000e\u0224\u1403\u000b", + "\u0224\u0003\u0225\u0003\u0225\u0003\u0225\u0003\u0225\u0003\u0225\u0003", + "\u0225\u0003\u0225\u0003\u0225\u0007\u0225\u140d\n\u0225\f\u0225\u000e", + "\u0225\u1410\u000b\u0225\u0003\u0225\u0003\u0225\u0003\u0226\u0006\u0226", + "\u1415\n\u0226\r\u0226\u000e\u0226\u1416\u0003\u0226\u0003\u0226\u0003", + "\u0227\u0003\u0227\u0005\u0227\u141d\n\u0227\u0003\u0227\u0005\u0227", + "\u1420\n\u0227\u0003\u0227\u0003\u0227\u0003\u0228\u0003\u0228\u0003", + "\u0228\u0003\u0228\u0007\u0228\u1428\n\u0228\f\u0228\u000e\u0228\u142b", + "\u000b\u0228\u0003\u0228\u0003\u0228\u0003\u0229\u0003\u0229\u0003\u0229", + "\u0003\u0229\u0007\u0229\u1433\n\u0229\f\u0229\u000e\u0229\u1436\u000b", + "\u0229\u0003\u0229\u0003\u0229\u0003\u0229\u0006\u0229\u143b\n\u0229", + "\r\u0229\u000e\u0229\u143c\u0003\u0229\u0003\u0229\u0006\u0229\u1441", + "\n\u0229\r\u0229\u000e\u0229\u1442\u0003\u0229\u0007\u0229\u1446\n\u0229", + "\f\u0229\u000e\u0229\u1449\u000b\u0229\u0003\u0229\u0007\u0229\u144c", + "\n\u0229\f\u0229\u000e\u0229\u144f\u000b\u0229\u0003\u0229\u0003\u0229", + "\u0003\u0229\u0003\u0229\u0003\u0229\u0003\u022a\u0003\u022a\u0003\u022a", + "\u0003\u022a\u0007\u022a\u145a\n\u022a\f\u022a\u000e\u022a\u145d\u000b", + "\u022a\u0003\u022a\u0003\u022a\u0003\u022a\u0006\u022a\u1462\n\u022a", + "\r\u022a\u000e\u022a\u1463\u0003\u022a\u0003\u022a\u0006\u022a\u1468", + "\n\u022a\r\u022a\u000e\u022a\u1469\u0003\u022a\u0005\u022a\u146d\n\u022a", + "\u0007\u022a\u146f\n\u022a\f\u022a\u000e\u022a\u1472\u000b\u022a\u0003", + "\u022a\u0006\u022a\u1475\n\u022a\r\u022a\u000e\u022a\u1476\u0003\u022a", + "\u0006\u022a\u147a\n\u022a\r\u022a\u000e\u022a\u147b\u0003\u022a\u0007", + "\u022a\u147f\n\u022a\f\u022a\u000e\u022a\u1482\u000b\u022a\u0003\u022a", + "\u0005\u022a\u1485\n\u022a\u0003\u022a\u0003\u022a\u0003\u022b\u0003", + "\u022b\u0003\u022b\u0003\u022b\u0007\u022b\u148d\n\u022b\f\u022b\u000e", + "\u022b\u1490\u000b\u022b\u0003\u022b\u0007\u022b\u1493\n\u022b\f\u022b", + "\u000e\u022b\u1496\u000b\u022b\u0003\u022b\u0003\u022b\u0007\u022b\u149a", + "\n\u022b\f\u022b\u000e\u022b\u149d\u000b\u022b\u0005\u022b\u149f\n\u022b", + "\u0003\u022c\u0003\u022c\u0003\u022c\u0003\u022d\u0003\u022d\u0003\u022e", + "\u0003\u022e\u0003\u022e\u0003\u022e\u0003\u022e\u0003\u022f\u0003\u022f", + "\u0005\u022f\u14ad\n\u022f\u0003\u022f\u0003\u022f\u0003\u0230\u0003", + "\u0230\u0003\u0230\u0003\u0230\u0003\u0230\u0003\u0230\u0003\u0230\u0003", + "\u0230\u0003\u0230\u0003\u0230\u0003\u0230\u0003\u0230\u0003\u0230\u0003", + "\u0230\u0003\u0230\u0003\u0230\u0003\u0230\u0003\u0230\u0003\u0230\u0003", + "\u0230\u0005\u0230\u14c5\n\u0230\u0003\u0230\u0007\u0230\u14c8\n\u0230", + "\f\u0230\u000e\u0230\u14cb\u000b\u0230\u0003\u0231\u0003\u0231\u0003", + "\u0231\u0003\u0231\u0003\u0231\u0003\u0232\u0003\u0232\u0005\u0232\u14d4", + "\n\u0232\u0003\u0232\u0003\u0232\u0003\u0233\u0003\u0233\u0003\u0233", + "\u0003\u0233\u0003\u0233\u0007\u0233\u14dd\n\u0233\f\u0233\u000e\u0233", + "\u14e0\u000b\u0233\u0003\u0234\u0003\u0234\u0003\u0234\u0003\u0234\u0003", + "\u0234\u0003\u0235\u0003\u0235\u0003\u0235\u0003\u0235\u0003\u0235\u0003", + "\u0235\u0003\u0236\u0003\u0236\u0003\u0236\u0003\u0236\u0003\u0236\u0003", + "\u0237\u0003\u0237\u0003\u0237\u0003\u0237\u0003\u0237\u0003\u0238\u0003", + "\u0238\u0003\u0238\u0003\u0238\u0003\u0238\u0003\u0239\u0003\u0239\u0003", + "\u0239\u0003\u0239\u0003\u0239\u0003\u023a\u0003\u023a\u0003\u023a\u0003", + "\u023a\u0003\u023a\u0003\u023b\u0006\u023b\u1507\n\u023b\r\u023b\u000e", + "\u023b\u1508\u0003\u023b\u0003\u023b\u0007\u023b\u150d\n\u023b\f\u023b", + "\u000e\u023b\u1510\u000b\u023b\u0005\u023b\u1512\n\u023b\u0003\u023c", + "\u0003\u023c\u0005\u023c\u1516\n\u023c\u0003\u023c\u0003\u023c\u0003", + "\u023c\u0003\u023c\u0003\u023c\u0003\u023c\u0003\u023c\u0002\u0002\u023d", + "\u0007\u0003\t\u0004\u000b\u0005\r\u0006\u000f\u0007\u0011\b\u0013\t", + "\u0015\n\u0017\u000b\u0019\f\u001b\r\u001d\u000e\u001f\u000f!\u0010", + "#\u0011%\u0012\'\u0013)\u0014+\u0015-\u0016/\u00171\u00183\u00195\u001a", + "7\u001b9\u001c;\u001d=\u001e?\u001fA\u0002C\u0002E\u0002G\u0002I K!", + "M\"O#Q$S%U&W\'Y([)]*_+a,c-e.g/i0k1m2o3q4s5u6w7y8{9}:\u007f;\u0081<\u0083", + "=\u0085>\u0087?\u0089@\u008bA\u008dB\u008fC\u0091D\u0093E\u0095F\u0097", + "G\u0099H\u009bI\u009dJ\u009fK\u00a1L\u00a3M\u00a5N\u00a7O\u00a9P\u00ab", + "Q\u00adR\u00afS\u00b1T\u00b3U\u00b5V\u00b7W\u00b9X\u00bbY\u00bdZ\u00bf", + "[\u00c1\\\u00c3]\u00c5^\u00c7_\u00c9`\u00cba\u00cdb\u00cfc\u00d1d\u00d3", + "e\u00d5f\u00d7g\u00d9h\u00dbi\u00ddj\u00dfk\u00e1l\u00e3m\u00e5n\u00e7", + "o\u00e9p\u00ebq\u00edr\u00efs\u00f1t\u00f3u\u00f5v\u00f7w\u00f9x\u00fb", + "y\u00fdz\u00ff{\u0101|\u0103}\u0105~\u0107\u007f\u0109\u0080\u010b\u0081", + "\u010d\u0082\u010f\u0083\u0111\u0084\u0113\u0085\u0115\u0086\u0117\u0087", + "\u0119\u0088\u011b\u0089\u011d\u008a\u011f\u008b\u0121\u008c\u0123\u008d", + "\u0125\u008e\u0127\u008f\u0129\u0090\u012b\u0091\u012d\u0092\u012f\u0093", + "\u0131\u0094\u0133\u0095\u0135\u0096\u0137\u0097\u0139\u0098\u013b\u0099", + "\u013d\u009a\u013f\u009b\u0141\u009c\u0143\u009d\u0145\u009e\u0147\u009f", + "\u0149\u00a0\u014b\u00a1\u014d\u00a2\u014f\u00a3\u0151\u00a4\u0153\u00a5", + "\u0155\u00a6\u0157\u00a7\u0159\u00a8\u015b\u00a9\u015d\u00aa\u015f\u00ab", + "\u0161\u00ac\u0163\u00ad\u0165\u00ae\u0167\u00af\u0169\u00b0\u016b\u00b1", + "\u016d\u00b2\u016f\u00b3\u0171\u00b4\u0173\u00b5\u0175\u00b6\u0177\u00b7", + "\u0179\u00b8\u017b\u00b9\u017d\u00ba\u017f\u00bb\u0181\u00bc\u0183\u00bd", + "\u0185\u00be\u0187\u00bf\u0189\u00c0\u018b\u00c1\u018d\u00c2\u018f\u00c3", + "\u0191\u00c4\u0193\u00c5\u0195\u00c6\u0197\u00c7\u0199\u00c8\u019b\u00c9", + "\u019d\u00ca\u019f\u00cb\u01a1\u00cc\u01a3\u00cd\u01a5\u00ce\u01a7\u00cf", + "\u01a9\u00d0\u01ab\u00d1\u01ad\u00d2\u01af\u00d3\u01b1\u00d4\u01b3\u00d5", + "\u01b5\u00d6\u01b7\u00d7\u01b9\u00d8\u01bb\u00d9\u01bd\u00da\u01bf\u00db", + "\u01c1\u00dc\u01c3\u00dd\u01c5\u00de\u01c7\u00df\u01c9\u00e0\u01cb\u00e1", + "\u01cd\u00e2\u01cf\u00e3\u01d1\u00e4\u01d3\u00e5\u01d5\u00e6\u01d7\u00e7", + "\u01d9\u00e8\u01db\u00e9\u01dd\u00ea\u01df\u00eb\u01e1\u00ec\u01e3\u00ed", + "\u01e5\u00ee\u01e7\u00ef\u01e9\u00f0\u01eb\u00f1\u01ed\u00f2\u01ef\u00f3", + "\u01f1\u00f4\u01f3\u00f5\u01f5\u00f6\u01f7\u00f7\u01f9\u00f8\u01fb\u00f9", + "\u01fd\u00fa\u01ff\u00fb\u0201\u00fc\u0203\u00fd\u0205\u00fe\u0207\u00ff", + "\u0209\u0100\u020b\u0101\u020d\u0102\u020f\u0103\u0211\u0104\u0213\u0105", + "\u0215\u0106\u0217\u0107\u0219\u0108\u021b\u0109\u021d\u010a\u021f\u010b", + "\u0221\u010c\u0223\u010d\u0225\u010e\u0227\u010f\u0229\u0110\u022b\u0111", + "\u022d\u0112\u022f\u0113\u0231\u0114\u0233\u0115\u0235\u0116\u0237\u0117", + "\u0239\u0118\u023b\u0119\u023d\u011a\u023f\u011b\u0241\u011c\u0243\u011d", + "\u0245\u011e\u0247\u011f\u0249\u0120\u024b\u0121\u024d\u0122\u024f\u0123", + "\u0251\u0124\u0253\u0125\u0255\u0126\u0257\u0127\u0259\u0128\u025b\u0129", + "\u025d\u012a\u025f\u012b\u0261\u012c\u0263\u012d\u0265\u012e\u0267\u012f", + "\u0269\u0130\u026b\u0131\u026d\u0132\u026f\u0133\u0271\u0134\u0273\u0135", + "\u0275\u0136\u0277\u0137\u0279\u0138\u027b\u0139\u027d\u013a\u027f\u013b", + "\u0281\u013c\u0283\u013d\u0285\u013e\u0287\u013f\u0289\u0140\u028b\u0141", + "\u028d\u0142\u028f\u0143\u0291\u0144\u0293\u0145\u0295\u0146\u0297\u0147", + "\u0299\u0148\u029b\u0149\u029d\u014a\u029f\u014b\u02a1\u014c\u02a3\u014d", + "\u02a5\u014e\u02a7\u014f\u02a9\u0150\u02ab\u0151\u02ad\u0152\u02af\u0153", + "\u02b1\u0154\u02b3\u0155\u02b5\u0156\u02b7\u0157\u02b9\u0158\u02bb\u0159", + "\u02bd\u015a\u02bf\u015b\u02c1\u015c\u02c3\u015d\u02c5\u015e\u02c7\u015f", + "\u02c9\u0160\u02cb\u0161\u02cd\u0162\u02cf\u0163\u02d1\u0164\u02d3\u0165", + "\u02d5\u0166\u02d7\u0167\u02d9\u0168\u02db\u0169\u02dd\u016a\u02df\u016b", + "\u02e1\u016c\u02e3\u016d\u02e5\u016e\u02e7\u016f\u02e9\u0170\u02eb\u0171", + "\u02ed\u0172\u02ef\u0173\u02f1\u0174\u02f3\u0175\u02f5\u0176\u02f7\u0177", + "\u02f9\u0178\u02fb\u0179\u02fd\u017a\u02ff\u017b\u0301\u017c\u0303\u017d", + "\u0305\u017e\u0307\u017f\u0309\u0180\u030b\u0181\u030d\u0182\u030f\u0183", + "\u0311\u0184\u0313\u0185\u0315\u0186\u0317\u0187\u0319\u0188\u031b\u0189", + "\u031d\u018a\u031f\u018b\u0321\u018c\u0323\u018d\u0325\u018e\u0327\u018f", + "\u0329\u0190\u032b\u0191\u032d\u0192\u032f\u0193\u0331\u0194\u0333\u0195", + "\u0335\u0196\u0337\u0197\u0339\u0198\u033b\u0199\u033d\u019a\u033f\u019b", + "\u0341\u019c\u0343\u019d\u0345\u019e\u0347\u019f\u0349\u01a0\u034b\u01a1", + "\u034d\u01a2\u034f\u01a3\u0351\u01a4\u0353\u01a5\u0355\u01a6\u0357\u01a7", + "\u0359\u01a8\u035b\u01a9\u035d\u01aa\u035f\u01ab\u0361\u01ac\u0363\u01ad", + "\u0365\u01ae\u0367\u01af\u0369\u01b0\u036b\u01b1\u036d\u01b2\u036f\u01b3", + "\u0371\u01b4\u0373\u01b5\u0375\u01b6\u0377\u01b7\u0379\u01b8\u037b\u01b9", + "\u037d\u01ba\u037f\u01bb\u0381\u01bc\u0383\u01bd\u0385\u01be\u0387\u01bf", + "\u0389\u01c0\u038b\u01c1\u038d\u01c2\u038f\u01c3\u0391\u01c4\u0393\u01c5", + "\u0395\u01c6\u0397\u01c7\u0399\u01c8\u039b\u01c9\u039d\u01ca\u039f\u01cb", + "\u03a1\u01cc\u03a3\u01cd\u03a5\u01ce\u03a7\u01cf\u03a9\u01d0\u03ab\u01d1", + "\u03ad\u01d2\u03af\u01d3\u03b1\u01d4\u03b3\u01d5\u03b5\u01d6\u03b7\u01d7", + "\u03b9\u01d8\u03bb\u01d9\u03bd\u01da\u03bf\u01db\u03c1\u01dc\u03c3\u01dd", + "\u03c5\u01de\u03c7\u01df\u03c9\u01e0\u03cb\u01e1\u03cd\u01e2\u03cf\u01e3", + "\u03d1\u01e4\u03d3\u01e5\u03d5\u01e6\u03d7\u01e7\u03d9\u01e8\u03db\u01e9", + "\u03dd\u01ea\u03df\u01eb\u03e1\u01ec\u03e3\u01ed\u03e5\u01ee\u03e7\u01ef", + "\u03e9\u01f0\u03eb\u01f1\u03ed\u01f2\u03ef\u01f3\u03f1\u01f4\u03f3\u01f5", + "\u03f5\u01f6\u03f7\u01f7\u03f9\u01f8\u03fb\u01f9\u03fd\u01fa\u03ff\u01fb", + "\u0401\u01fc\u0403\u01fd\u0405\u01fe\u0407\u01ff\u0409\u0200\u040b\u0201", + "\u040d\u0202\u040f\u0002\u0411\u0002\u0413\u0002\u0415\u0203\u0417\u0204", + "\u0419\u0205\u041b\u0206\u041d\u0207\u041f\u0208\u0421\u0209\u0423\u020a", + "\u0425\u020b\u0427\u020c\u0429\u0002\u042b\u020d\u042d\u020e\u042f\u020f", + "\u0431\u0002\u0433\u0210\u0435\u0211\u0437\u0212\u0439\u0213\u043b\u0214", + "\u043d\u0215\u043f\u0216\u0441\u0217\u0443\u0218\u0445\u0219\u0447\u021a", + "\u0449\u0002\u044b\u021b\u044d\u021c\u044f\u021d\u0451\u021e\u0453\u021f", + "\u0455\u0220\u0457\u0221\u0459\u0222\u045b\u0223\u045d\u0224\u045f\u0225", + "\u0461\u0226\u0463\u0002\u0465\u0227\u0467\u0228\u0469\u0002\u046b\u0002", + "\u046d\u0002\u046f\u0229\u0471\u0002\u0473\u0002\u0475\u022d\u0477\u022a", + "\u0479\u022b\u047b\u022c\u0007\u0002\u0003\u0004\u0005\u0006\u001c\u0003", + "\u00022;\u0004\u0002--//\u000b\u0002##%%\'(,,>B``bb~~\u0080\u0080\u0004", + "\u0002,->@\n\u0002##%%\'(AB``bb~~\u0080\u0080\u000b\u0002C\\aac|\u00ac", + "\u00ac\u00b7\u00b7\u00bc\u00bc\u00c2\u00d8\u00da\u00f8\u00fa\u0101\u0004", + "\u0002\u0102\ud801\ue002\u0001\u0003\u0002\ud802\udc01\u0003\u0002\udc02", + "\ue001\u0004\u0002\u0002\u0002$$\u0003\u0002$$\u0003\u0002))\u0003\u0002", + "23\u0004\u00022;CH\u0004\u0002C\\aa\u0006\u0002&&2;C\\aa\u0004\u0002", + "$$^^\u0004\u0002\u000b\u000b\"\"\u0004\u0002\f\f\u000f\u000f\u0004\u0002", + ",,11\u0006\u0002\f\f\u000f\u000f$$^^\u0005\u0002\f\f\u000f\u000f$$\u0005", + "\u00022;CHch\u0005\u0002WWwwzz\u0004\u0002))^^\u0003\u0002&&\u0002\u1566", + "\u0002\u0007\u0003\u0002\u0002\u0002\u0002\t\u0003\u0002\u0002\u0002", + "\u0002\u000b\u0003\u0002\u0002\u0002\u0002\r\u0003\u0002\u0002\u0002", + "\u0002\u000f\u0003\u0002\u0002\u0002\u0002\u0011\u0003\u0002\u0002\u0002", + "\u0002\u0013\u0003\u0002\u0002\u0002\u0002\u0015\u0003\u0002\u0002\u0002", + "\u0002\u0017\u0003\u0002\u0002\u0002\u0002\u0019\u0003\u0002\u0002\u0002", + "\u0002\u001b\u0003\u0002\u0002\u0002\u0002\u001d\u0003\u0002\u0002\u0002", + "\u0002\u001f\u0003\u0002\u0002\u0002\u0002!\u0003\u0002\u0002\u0002", + "\u0002#\u0003\u0002\u0002\u0002\u0002%\u0003\u0002\u0002\u0002\u0002", + "\'\u0003\u0002\u0002\u0002\u0002)\u0003\u0002\u0002\u0002\u0002+\u0003", + "\u0002\u0002\u0002\u0002-\u0003\u0002\u0002\u0002\u0002/\u0003\u0002", + "\u0002\u0002\u00021\u0003\u0002\u0002\u0002\u00023\u0003\u0002\u0002", + "\u0002\u00025\u0003\u0002\u0002\u0002\u00027\u0003\u0002\u0002\u0002", + "\u00029\u0003\u0002\u0002\u0002\u0002;\u0003\u0002\u0002\u0002\u0002", + "=\u0003\u0002\u0002\u0002\u0002?\u0003\u0002\u0002\u0002\u0002A\u0003", + "\u0002\u0002\u0002\u0002I\u0003\u0002\u0002\u0002\u0002K\u0003\u0002", + "\u0002\u0002\u0002M\u0003\u0002\u0002\u0002\u0002O\u0003\u0002\u0002", + "\u0002\u0002Q\u0003\u0002\u0002\u0002\u0002S\u0003\u0002\u0002\u0002", + "\u0002U\u0003\u0002\u0002\u0002\u0002W\u0003\u0002\u0002\u0002\u0002", + "Y\u0003\u0002\u0002\u0002\u0002[\u0003\u0002\u0002\u0002\u0002]\u0003", + "\u0002\u0002\u0002\u0002_\u0003\u0002\u0002\u0002\u0002a\u0003\u0002", + "\u0002\u0002\u0002c\u0003\u0002\u0002\u0002\u0002e\u0003\u0002\u0002", + "\u0002\u0002g\u0003\u0002\u0002\u0002\u0002i\u0003\u0002\u0002\u0002", + "\u0002k\u0003\u0002\u0002\u0002\u0002m\u0003\u0002\u0002\u0002\u0002", + "o\u0003\u0002\u0002\u0002\u0002q\u0003\u0002\u0002\u0002\u0002s\u0003", + "\u0002\u0002\u0002\u0002u\u0003\u0002\u0002\u0002\u0002w\u0003\u0002", + "\u0002\u0002\u0002y\u0003\u0002\u0002\u0002\u0002{\u0003\u0002\u0002", + "\u0002\u0002}\u0003\u0002\u0002\u0002\u0002\u007f\u0003\u0002\u0002", + "\u0002\u0002\u0081\u0003\u0002\u0002\u0002\u0002\u0083\u0003\u0002\u0002", + "\u0002\u0002\u0085\u0003\u0002\u0002\u0002\u0002\u0087\u0003\u0002\u0002", + "\u0002\u0002\u0089\u0003\u0002\u0002\u0002\u0002\u008b\u0003\u0002\u0002", + "\u0002\u0002\u008d\u0003\u0002\u0002\u0002\u0002\u008f\u0003\u0002\u0002", + "\u0002\u0002\u0091\u0003\u0002\u0002\u0002\u0002\u0093\u0003\u0002\u0002", + "\u0002\u0002\u0095\u0003\u0002\u0002\u0002\u0002\u0097\u0003\u0002\u0002", + "\u0002\u0002\u0099\u0003\u0002\u0002\u0002\u0002\u009b\u0003\u0002\u0002", + "\u0002\u0002\u009d\u0003\u0002\u0002\u0002\u0002\u009f\u0003\u0002\u0002", + "\u0002\u0002\u00a1\u0003\u0002\u0002\u0002\u0002\u00a3\u0003\u0002\u0002", + "\u0002\u0002\u00a5\u0003\u0002\u0002\u0002\u0002\u00a7\u0003\u0002\u0002", + "\u0002\u0002\u00a9\u0003\u0002\u0002\u0002\u0002\u00ab\u0003\u0002\u0002", + "\u0002\u0002\u00ad\u0003\u0002\u0002\u0002\u0002\u00af\u0003\u0002\u0002", + "\u0002\u0002\u00b1\u0003\u0002\u0002\u0002\u0002\u00b3\u0003\u0002\u0002", + "\u0002\u0002\u00b5\u0003\u0002\u0002\u0002\u0002\u00b7\u0003\u0002\u0002", + "\u0002\u0002\u00b9\u0003\u0002\u0002\u0002\u0002\u00bb\u0003\u0002\u0002", + "\u0002\u0002\u00bd\u0003\u0002\u0002\u0002\u0002\u00bf\u0003\u0002\u0002", + "\u0002\u0002\u00c1\u0003\u0002\u0002\u0002\u0002\u00c3\u0003\u0002\u0002", + "\u0002\u0002\u00c5\u0003\u0002\u0002\u0002\u0002\u00c7\u0003\u0002\u0002", + "\u0002\u0002\u00c9\u0003\u0002\u0002\u0002\u0002\u00cb\u0003\u0002\u0002", + "\u0002\u0002\u00cd\u0003\u0002\u0002\u0002\u0002\u00cf\u0003\u0002\u0002", + "\u0002\u0002\u00d1\u0003\u0002\u0002\u0002\u0002\u00d3\u0003\u0002\u0002", + "\u0002\u0002\u00d5\u0003\u0002\u0002\u0002\u0002\u00d7\u0003\u0002\u0002", + "\u0002\u0002\u00d9\u0003\u0002\u0002\u0002\u0002\u00db\u0003\u0002\u0002", + "\u0002\u0002\u00dd\u0003\u0002\u0002\u0002\u0002\u00df\u0003\u0002\u0002", + "\u0002\u0002\u00e1\u0003\u0002\u0002\u0002\u0002\u00e3\u0003\u0002\u0002", + "\u0002\u0002\u00e5\u0003\u0002\u0002\u0002\u0002\u00e7\u0003\u0002\u0002", + "\u0002\u0002\u00e9\u0003\u0002\u0002\u0002\u0002\u00eb\u0003\u0002\u0002", + "\u0002\u0002\u00ed\u0003\u0002\u0002\u0002\u0002\u00ef\u0003\u0002\u0002", + "\u0002\u0002\u00f1\u0003\u0002\u0002\u0002\u0002\u00f3\u0003\u0002\u0002", + "\u0002\u0002\u00f5\u0003\u0002\u0002\u0002\u0002\u00f7\u0003\u0002\u0002", + "\u0002\u0002\u00f9\u0003\u0002\u0002\u0002\u0002\u00fb\u0003\u0002\u0002", + "\u0002\u0002\u00fd\u0003\u0002\u0002\u0002\u0002\u00ff\u0003\u0002\u0002", + "\u0002\u0002\u0101\u0003\u0002\u0002\u0002\u0002\u0103\u0003\u0002\u0002", + "\u0002\u0002\u0105\u0003\u0002\u0002\u0002\u0002\u0107\u0003\u0002\u0002", + "\u0002\u0002\u0109\u0003\u0002\u0002\u0002\u0002\u010b\u0003\u0002\u0002", + "\u0002\u0002\u010d\u0003\u0002\u0002\u0002\u0002\u010f\u0003\u0002\u0002", + "\u0002\u0002\u0111\u0003\u0002\u0002\u0002\u0002\u0113\u0003\u0002\u0002", + "\u0002\u0002\u0115\u0003\u0002\u0002\u0002\u0002\u0117\u0003\u0002\u0002", + "\u0002\u0002\u0119\u0003\u0002\u0002\u0002\u0002\u011b\u0003\u0002\u0002", + "\u0002\u0002\u011d\u0003\u0002\u0002\u0002\u0002\u011f\u0003\u0002\u0002", + "\u0002\u0002\u0121\u0003\u0002\u0002\u0002\u0002\u0123\u0003\u0002\u0002", + "\u0002\u0002\u0125\u0003\u0002\u0002\u0002\u0002\u0127\u0003\u0002\u0002", + "\u0002\u0002\u0129\u0003\u0002\u0002\u0002\u0002\u012b\u0003\u0002\u0002", + "\u0002\u0002\u012d\u0003\u0002\u0002\u0002\u0002\u012f\u0003\u0002\u0002", + "\u0002\u0002\u0131\u0003\u0002\u0002\u0002\u0002\u0133\u0003\u0002\u0002", + "\u0002\u0002\u0135\u0003\u0002\u0002\u0002\u0002\u0137\u0003\u0002\u0002", + "\u0002\u0002\u0139\u0003\u0002\u0002\u0002\u0002\u013b\u0003\u0002\u0002", + "\u0002\u0002\u013d\u0003\u0002\u0002\u0002\u0002\u013f\u0003\u0002\u0002", + "\u0002\u0002\u0141\u0003\u0002\u0002\u0002\u0002\u0143\u0003\u0002\u0002", + "\u0002\u0002\u0145\u0003\u0002\u0002\u0002\u0002\u0147\u0003\u0002\u0002", + "\u0002\u0002\u0149\u0003\u0002\u0002\u0002\u0002\u014b\u0003\u0002\u0002", + "\u0002\u0002\u014d\u0003\u0002\u0002\u0002\u0002\u014f\u0003\u0002\u0002", + "\u0002\u0002\u0151\u0003\u0002\u0002\u0002\u0002\u0153\u0003\u0002\u0002", + "\u0002\u0002\u0155\u0003\u0002\u0002\u0002\u0002\u0157\u0003\u0002\u0002", + "\u0002\u0002\u0159\u0003\u0002\u0002\u0002\u0002\u015b\u0003\u0002\u0002", + "\u0002\u0002\u015d\u0003\u0002\u0002\u0002\u0002\u015f\u0003\u0002\u0002", + "\u0002\u0002\u0161\u0003\u0002\u0002\u0002\u0002\u0163\u0003\u0002\u0002", + "\u0002\u0002\u0165\u0003\u0002\u0002\u0002\u0002\u0167\u0003\u0002\u0002", + "\u0002\u0002\u0169\u0003\u0002\u0002\u0002\u0002\u016b\u0003\u0002\u0002", + "\u0002\u0002\u016d\u0003\u0002\u0002\u0002\u0002\u016f\u0003\u0002\u0002", + "\u0002\u0002\u0171\u0003\u0002\u0002\u0002\u0002\u0173\u0003\u0002\u0002", + "\u0002\u0002\u0175\u0003\u0002\u0002\u0002\u0002\u0177\u0003\u0002\u0002", + "\u0002\u0002\u0179\u0003\u0002\u0002\u0002\u0002\u017b\u0003\u0002\u0002", + "\u0002\u0002\u017d\u0003\u0002\u0002\u0002\u0002\u017f\u0003\u0002\u0002", + "\u0002\u0002\u0181\u0003\u0002\u0002\u0002\u0002\u0183\u0003\u0002\u0002", + "\u0002\u0002\u0185\u0003\u0002\u0002\u0002\u0002\u0187\u0003\u0002\u0002", + "\u0002\u0002\u0189\u0003\u0002\u0002\u0002\u0002\u018b\u0003\u0002\u0002", + "\u0002\u0002\u018d\u0003\u0002\u0002\u0002\u0002\u018f\u0003\u0002\u0002", + "\u0002\u0002\u0191\u0003\u0002\u0002\u0002\u0002\u0193\u0003\u0002\u0002", + "\u0002\u0002\u0195\u0003\u0002\u0002\u0002\u0002\u0197\u0003\u0002\u0002", + "\u0002\u0002\u0199\u0003\u0002\u0002\u0002\u0002\u019b\u0003\u0002\u0002", + "\u0002\u0002\u019d\u0003\u0002\u0002\u0002\u0002\u019f\u0003\u0002\u0002", + "\u0002\u0002\u01a1\u0003\u0002\u0002\u0002\u0002\u01a3\u0003\u0002\u0002", + "\u0002\u0002\u01a5\u0003\u0002\u0002\u0002\u0002\u01a7\u0003\u0002\u0002", + "\u0002\u0002\u01a9\u0003\u0002\u0002\u0002\u0002\u01ab\u0003\u0002\u0002", + "\u0002\u0002\u01ad\u0003\u0002\u0002\u0002\u0002\u01af\u0003\u0002\u0002", + "\u0002\u0002\u01b1\u0003\u0002\u0002\u0002\u0002\u01b3\u0003\u0002\u0002", + "\u0002\u0002\u01b5\u0003\u0002\u0002\u0002\u0002\u01b7\u0003\u0002\u0002", + "\u0002\u0002\u01b9\u0003\u0002\u0002\u0002\u0002\u01bb\u0003\u0002\u0002", + "\u0002\u0002\u01bd\u0003\u0002\u0002\u0002\u0002\u01bf\u0003\u0002\u0002", + "\u0002\u0002\u01c1\u0003\u0002\u0002\u0002\u0002\u01c3\u0003\u0002\u0002", + "\u0002\u0002\u01c5\u0003\u0002\u0002\u0002\u0002\u01c7\u0003\u0002\u0002", + "\u0002\u0002\u01c9\u0003\u0002\u0002\u0002\u0002\u01cb\u0003\u0002\u0002", + "\u0002\u0002\u01cd\u0003\u0002\u0002\u0002\u0002\u01cf\u0003\u0002\u0002", + "\u0002\u0002\u01d1\u0003\u0002\u0002\u0002\u0002\u01d3\u0003\u0002\u0002", + "\u0002\u0002\u01d5\u0003\u0002\u0002\u0002\u0002\u01d7\u0003\u0002\u0002", + "\u0002\u0002\u01d9\u0003\u0002\u0002\u0002\u0002\u01db\u0003\u0002\u0002", + "\u0002\u0002\u01dd\u0003\u0002\u0002\u0002\u0002\u01df\u0003\u0002\u0002", + "\u0002\u0002\u01e1\u0003\u0002\u0002\u0002\u0002\u01e3\u0003\u0002\u0002", + "\u0002\u0002\u01e5\u0003\u0002\u0002\u0002\u0002\u01e7\u0003\u0002\u0002", + "\u0002\u0002\u01e9\u0003\u0002\u0002\u0002\u0002\u01eb\u0003\u0002\u0002", + "\u0002\u0002\u01ed\u0003\u0002\u0002\u0002\u0002\u01ef\u0003\u0002\u0002", + "\u0002\u0002\u01f1\u0003\u0002\u0002\u0002\u0002\u01f3\u0003\u0002\u0002", + "\u0002\u0002\u01f5\u0003\u0002\u0002\u0002\u0002\u01f7\u0003\u0002\u0002", + "\u0002\u0002\u01f9\u0003\u0002\u0002\u0002\u0002\u01fb\u0003\u0002\u0002", + "\u0002\u0002\u01fd\u0003\u0002\u0002\u0002\u0002\u01ff\u0003\u0002\u0002", + "\u0002\u0002\u0201\u0003\u0002\u0002\u0002\u0002\u0203\u0003\u0002\u0002", + "\u0002\u0002\u0205\u0003\u0002\u0002\u0002\u0002\u0207\u0003\u0002\u0002", + "\u0002\u0002\u0209\u0003\u0002\u0002\u0002\u0002\u020b\u0003\u0002\u0002", + "\u0002\u0002\u020d\u0003\u0002\u0002\u0002\u0002\u020f\u0003\u0002\u0002", + "\u0002\u0002\u0211\u0003\u0002\u0002\u0002\u0002\u0213\u0003\u0002\u0002", + "\u0002\u0002\u0215\u0003\u0002\u0002\u0002\u0002\u0217\u0003\u0002\u0002", + "\u0002\u0002\u0219\u0003\u0002\u0002\u0002\u0002\u021b\u0003\u0002\u0002", + "\u0002\u0002\u021d\u0003\u0002\u0002\u0002\u0002\u021f\u0003\u0002\u0002", + "\u0002\u0002\u0221\u0003\u0002\u0002\u0002\u0002\u0223\u0003\u0002\u0002", + "\u0002\u0002\u0225\u0003\u0002\u0002\u0002\u0002\u0227\u0003\u0002\u0002", + "\u0002\u0002\u0229\u0003\u0002\u0002\u0002\u0002\u022b\u0003\u0002\u0002", + "\u0002\u0002\u022d\u0003\u0002\u0002\u0002\u0002\u022f\u0003\u0002\u0002", + "\u0002\u0002\u0231\u0003\u0002\u0002\u0002\u0002\u0233\u0003\u0002\u0002", + "\u0002\u0002\u0235\u0003\u0002\u0002\u0002\u0002\u0237\u0003\u0002\u0002", + "\u0002\u0002\u0239\u0003\u0002\u0002\u0002\u0002\u023b\u0003\u0002\u0002", + "\u0002\u0002\u023d\u0003\u0002\u0002\u0002\u0002\u023f\u0003\u0002\u0002", + "\u0002\u0002\u0241\u0003\u0002\u0002\u0002\u0002\u0243\u0003\u0002\u0002", + "\u0002\u0002\u0245\u0003\u0002\u0002\u0002\u0002\u0247\u0003\u0002\u0002", + "\u0002\u0002\u0249\u0003\u0002\u0002\u0002\u0002\u024b\u0003\u0002\u0002", + "\u0002\u0002\u024d\u0003\u0002\u0002\u0002\u0002\u024f\u0003\u0002\u0002", + "\u0002\u0002\u0251\u0003\u0002\u0002\u0002\u0002\u0253\u0003\u0002\u0002", + "\u0002\u0002\u0255\u0003\u0002\u0002\u0002\u0002\u0257\u0003\u0002\u0002", + "\u0002\u0002\u0259\u0003\u0002\u0002\u0002\u0002\u025b\u0003\u0002\u0002", + "\u0002\u0002\u025d\u0003\u0002\u0002\u0002\u0002\u025f\u0003\u0002\u0002", + "\u0002\u0002\u0261\u0003\u0002\u0002\u0002\u0002\u0263\u0003\u0002\u0002", + "\u0002\u0002\u0265\u0003\u0002\u0002\u0002\u0002\u0267\u0003\u0002\u0002", + "\u0002\u0002\u0269\u0003\u0002\u0002\u0002\u0002\u026b\u0003\u0002\u0002", + "\u0002\u0002\u026d\u0003\u0002\u0002\u0002\u0002\u026f\u0003\u0002\u0002", + "\u0002\u0002\u0271\u0003\u0002\u0002\u0002\u0002\u0273\u0003\u0002\u0002", + "\u0002\u0002\u0275\u0003\u0002\u0002\u0002\u0002\u0277\u0003\u0002\u0002", + "\u0002\u0002\u0279\u0003\u0002\u0002\u0002\u0002\u027b\u0003\u0002\u0002", + "\u0002\u0002\u027d\u0003\u0002\u0002\u0002\u0002\u027f\u0003\u0002\u0002", + "\u0002\u0002\u0281\u0003\u0002\u0002\u0002\u0002\u0283\u0003\u0002\u0002", + "\u0002\u0002\u0285\u0003\u0002\u0002\u0002\u0002\u0287\u0003\u0002\u0002", + "\u0002\u0002\u0289\u0003\u0002\u0002\u0002\u0002\u028b\u0003\u0002\u0002", + "\u0002\u0002\u028d\u0003\u0002\u0002\u0002\u0002\u028f\u0003\u0002\u0002", + "\u0002\u0002\u0291\u0003\u0002\u0002\u0002\u0002\u0293\u0003\u0002\u0002", + "\u0002\u0002\u0295\u0003\u0002\u0002\u0002\u0002\u0297\u0003\u0002\u0002", + "\u0002\u0002\u0299\u0003\u0002\u0002\u0002\u0002\u029b\u0003\u0002\u0002", + "\u0002\u0002\u029d\u0003\u0002\u0002\u0002\u0002\u029f\u0003\u0002\u0002", + "\u0002\u0002\u02a1\u0003\u0002\u0002\u0002\u0002\u02a3\u0003\u0002\u0002", + "\u0002\u0002\u02a5\u0003\u0002\u0002\u0002\u0002\u02a7\u0003\u0002\u0002", + "\u0002\u0002\u02a9\u0003\u0002\u0002\u0002\u0002\u02ab\u0003\u0002\u0002", + "\u0002\u0002\u02ad\u0003\u0002\u0002\u0002\u0002\u02af\u0003\u0002\u0002", + "\u0002\u0002\u02b1\u0003\u0002\u0002\u0002\u0002\u02b3\u0003\u0002\u0002", + "\u0002\u0002\u02b5\u0003\u0002\u0002\u0002\u0002\u02b7\u0003\u0002\u0002", + "\u0002\u0002\u02b9\u0003\u0002\u0002\u0002\u0002\u02bb\u0003\u0002\u0002", + "\u0002\u0002\u02bd\u0003\u0002\u0002\u0002\u0002\u02bf\u0003\u0002\u0002", + "\u0002\u0002\u02c1\u0003\u0002\u0002\u0002\u0002\u02c3\u0003\u0002\u0002", + "\u0002\u0002\u02c5\u0003\u0002\u0002\u0002\u0002\u02c7\u0003\u0002\u0002", + "\u0002\u0002\u02c9\u0003\u0002\u0002\u0002\u0002\u02cb\u0003\u0002\u0002", + "\u0002\u0002\u02cd\u0003\u0002\u0002\u0002\u0002\u02cf\u0003\u0002\u0002", + "\u0002\u0002\u02d1\u0003\u0002\u0002\u0002\u0002\u02d3\u0003\u0002\u0002", + "\u0002\u0002\u02d5\u0003\u0002\u0002\u0002\u0002\u02d7\u0003\u0002\u0002", + "\u0002\u0002\u02d9\u0003\u0002\u0002\u0002\u0002\u02db\u0003\u0002\u0002", + "\u0002\u0002\u02dd\u0003\u0002\u0002\u0002\u0002\u02df\u0003\u0002\u0002", + "\u0002\u0002\u02e1\u0003\u0002\u0002\u0002\u0002\u02e3\u0003\u0002\u0002", + "\u0002\u0002\u02e5\u0003\u0002\u0002\u0002\u0002\u02e7\u0003\u0002\u0002", + "\u0002\u0002\u02e9\u0003\u0002\u0002\u0002\u0002\u02eb\u0003\u0002\u0002", + "\u0002\u0002\u02ed\u0003\u0002\u0002\u0002\u0002\u02ef\u0003\u0002\u0002", + "\u0002\u0002\u02f1\u0003\u0002\u0002\u0002\u0002\u02f3\u0003\u0002\u0002", + "\u0002\u0002\u02f5\u0003\u0002\u0002\u0002\u0002\u02f7\u0003\u0002\u0002", + "\u0002\u0002\u02f9\u0003\u0002\u0002\u0002\u0002\u02fb\u0003\u0002\u0002", + "\u0002\u0002\u02fd\u0003\u0002\u0002\u0002\u0002\u02ff\u0003\u0002\u0002", + "\u0002\u0002\u0301\u0003\u0002\u0002\u0002\u0002\u0303\u0003\u0002\u0002", + "\u0002\u0002\u0305\u0003\u0002\u0002\u0002\u0002\u0307\u0003\u0002\u0002", + "\u0002\u0002\u0309\u0003\u0002\u0002\u0002\u0002\u030b\u0003\u0002\u0002", + "\u0002\u0002\u030d\u0003\u0002\u0002\u0002\u0002\u030f\u0003\u0002\u0002", + "\u0002\u0002\u0311\u0003\u0002\u0002\u0002\u0002\u0313\u0003\u0002\u0002", + "\u0002\u0002\u0315\u0003\u0002\u0002\u0002\u0002\u0317\u0003\u0002\u0002", + "\u0002\u0002\u0319\u0003\u0002\u0002\u0002\u0002\u031b\u0003\u0002\u0002", + "\u0002\u0002\u031d\u0003\u0002\u0002\u0002\u0002\u031f\u0003\u0002\u0002", + "\u0002\u0002\u0321\u0003\u0002\u0002\u0002\u0002\u0323\u0003\u0002\u0002", + "\u0002\u0002\u0325\u0003\u0002\u0002\u0002\u0002\u0327\u0003\u0002\u0002", + "\u0002\u0002\u0329\u0003\u0002\u0002\u0002\u0002\u032b\u0003\u0002\u0002", + "\u0002\u0002\u032d\u0003\u0002\u0002\u0002\u0002\u032f\u0003\u0002\u0002", + "\u0002\u0002\u0331\u0003\u0002\u0002\u0002\u0002\u0333\u0003\u0002\u0002", + "\u0002\u0002\u0335\u0003\u0002\u0002\u0002\u0002\u0337\u0003\u0002\u0002", + "\u0002\u0002\u0339\u0003\u0002\u0002\u0002\u0002\u033b\u0003\u0002\u0002", + "\u0002\u0002\u033d\u0003\u0002\u0002\u0002\u0002\u033f\u0003\u0002\u0002", + "\u0002\u0002\u0341\u0003\u0002\u0002\u0002\u0002\u0343\u0003\u0002\u0002", + "\u0002\u0002\u0345\u0003\u0002\u0002\u0002\u0002\u0347\u0003\u0002\u0002", + "\u0002\u0002\u0349\u0003\u0002\u0002\u0002\u0002\u034b\u0003\u0002\u0002", + "\u0002\u0002\u034d\u0003\u0002\u0002\u0002\u0002\u034f\u0003\u0002\u0002", + "\u0002\u0002\u0351\u0003\u0002\u0002\u0002\u0002\u0353\u0003\u0002\u0002", + "\u0002\u0002\u0355\u0003\u0002\u0002\u0002\u0002\u0357\u0003\u0002\u0002", + "\u0002\u0002\u0359\u0003\u0002\u0002\u0002\u0002\u035b\u0003\u0002\u0002", + "\u0002\u0002\u035d\u0003\u0002\u0002\u0002\u0002\u035f\u0003\u0002\u0002", + "\u0002\u0002\u0361\u0003\u0002\u0002\u0002\u0002\u0363\u0003\u0002\u0002", + "\u0002\u0002\u0365\u0003\u0002\u0002\u0002\u0002\u0367\u0003\u0002\u0002", + "\u0002\u0002\u0369\u0003\u0002\u0002\u0002\u0002\u036b\u0003\u0002\u0002", + "\u0002\u0002\u036d\u0003\u0002\u0002\u0002\u0002\u036f\u0003\u0002\u0002", + "\u0002\u0002\u0371\u0003\u0002\u0002\u0002\u0002\u0373\u0003\u0002\u0002", + "\u0002\u0002\u0375\u0003\u0002\u0002\u0002\u0002\u0377\u0003\u0002\u0002", + "\u0002\u0002\u0379\u0003\u0002\u0002\u0002\u0002\u037b\u0003\u0002\u0002", + "\u0002\u0002\u037d\u0003\u0002\u0002\u0002\u0002\u037f\u0003\u0002\u0002", + "\u0002\u0002\u0381\u0003\u0002\u0002\u0002\u0002\u0383\u0003\u0002\u0002", + "\u0002\u0002\u0385\u0003\u0002\u0002\u0002\u0002\u0387\u0003\u0002\u0002", + "\u0002\u0002\u0389\u0003\u0002\u0002\u0002\u0002\u038b\u0003\u0002\u0002", + "\u0002\u0002\u038d\u0003\u0002\u0002\u0002\u0002\u038f\u0003\u0002\u0002", + "\u0002\u0002\u0391\u0003\u0002\u0002\u0002\u0002\u0393\u0003\u0002\u0002", + "\u0002\u0002\u0395\u0003\u0002\u0002\u0002\u0002\u0397\u0003\u0002\u0002", + "\u0002\u0002\u0399\u0003\u0002\u0002\u0002\u0002\u039b\u0003\u0002\u0002", + "\u0002\u0002\u039d\u0003\u0002\u0002\u0002\u0002\u039f\u0003\u0002\u0002", + "\u0002\u0002\u03a1\u0003\u0002\u0002\u0002\u0002\u03a3\u0003\u0002\u0002", + "\u0002\u0002\u03a5\u0003\u0002\u0002\u0002\u0002\u03a7\u0003\u0002\u0002", + "\u0002\u0002\u03a9\u0003\u0002\u0002\u0002\u0002\u03ab\u0003\u0002\u0002", + "\u0002\u0002\u03ad\u0003\u0002\u0002\u0002\u0002\u03af\u0003\u0002\u0002", + "\u0002\u0002\u03b1\u0003\u0002\u0002\u0002\u0002\u03b3\u0003\u0002\u0002", + "\u0002\u0002\u03b5\u0003\u0002\u0002\u0002\u0002\u03b7\u0003\u0002\u0002", + "\u0002\u0002\u03b9\u0003\u0002\u0002\u0002\u0002\u03bb\u0003\u0002\u0002", + "\u0002\u0002\u03bd\u0003\u0002\u0002\u0002\u0002\u03bf\u0003\u0002\u0002", + "\u0002\u0002\u03c1\u0003\u0002\u0002\u0002\u0002\u03c3\u0003\u0002\u0002", + "\u0002\u0002\u03c5\u0003\u0002\u0002\u0002\u0002\u03c7\u0003\u0002\u0002", + "\u0002\u0002\u03c9\u0003\u0002\u0002\u0002\u0002\u03cb\u0003\u0002\u0002", + "\u0002\u0002\u03cd\u0003\u0002\u0002\u0002\u0002\u03cf\u0003\u0002\u0002", + "\u0002\u0002\u03d1\u0003\u0002\u0002\u0002\u0002\u03d3\u0003\u0002\u0002", + "\u0002\u0002\u03d5\u0003\u0002\u0002\u0002\u0002\u03d7\u0003\u0002\u0002", + "\u0002\u0002\u03d9\u0003\u0002\u0002\u0002\u0002\u03db\u0003\u0002\u0002", + "\u0002\u0002\u03dd\u0003\u0002\u0002\u0002\u0002\u03df\u0003\u0002\u0002", + "\u0002\u0002\u03e1\u0003\u0002\u0002\u0002\u0002\u03e3\u0003\u0002\u0002", + "\u0002\u0002\u03e5\u0003\u0002\u0002\u0002\u0002\u03e7\u0003\u0002\u0002", + "\u0002\u0002\u03e9\u0003\u0002\u0002\u0002\u0002\u03eb\u0003\u0002\u0002", + "\u0002\u0002\u03ed\u0003\u0002\u0002\u0002\u0002\u03ef\u0003\u0002\u0002", + "\u0002\u0002\u03f1\u0003\u0002\u0002\u0002\u0002\u03f3\u0003\u0002\u0002", + "\u0002\u0002\u03f5\u0003\u0002\u0002\u0002\u0002\u03f7\u0003\u0002\u0002", + "\u0002\u0002\u03f9\u0003\u0002\u0002\u0002\u0002\u03fb\u0003\u0002\u0002", + "\u0002\u0002\u03fd\u0003\u0002\u0002\u0002\u0002\u03ff\u0003\u0002\u0002", + "\u0002\u0002\u0401\u0003\u0002\u0002\u0002\u0002\u0403\u0003\u0002\u0002", + "\u0002\u0002\u0405\u0003\u0002\u0002\u0002\u0002\u0407\u0003\u0002\u0002", + "\u0002\u0002\u0409\u0003\u0002\u0002\u0002\u0002\u040b\u0003\u0002\u0002", + "\u0002\u0002\u040d\u0003\u0002\u0002\u0002\u0002\u0415\u0003\u0002\u0002", + "\u0002\u0002\u0417\u0003\u0002\u0002\u0002\u0002\u0419\u0003\u0002\u0002", + "\u0002\u0002\u041b\u0003\u0002\u0002\u0002\u0002\u041d\u0003\u0002\u0002", + "\u0002\u0002\u041f\u0003\u0002\u0002\u0002\u0002\u0421\u0003\u0002\u0002", + "\u0002\u0002\u0423\u0003\u0002\u0002\u0002\u0002\u0425\u0003\u0002\u0002", + "\u0002\u0002\u0427\u0003\u0002\u0002\u0002\u0002\u0429\u0003\u0002\u0002", + "\u0002\u0002\u042b\u0003\u0002\u0002\u0002\u0002\u042d\u0003\u0002\u0002", + "\u0002\u0002\u042f\u0003\u0002\u0002\u0002\u0002\u0433\u0003\u0002\u0002", + "\u0002\u0002\u0435\u0003\u0002\u0002\u0002\u0002\u0437\u0003\u0002\u0002", + "\u0002\u0002\u0439\u0003\u0002\u0002\u0002\u0002\u043b\u0003\u0002\u0002", + "\u0002\u0002\u043d\u0003\u0002\u0002\u0002\u0002\u043f\u0003\u0002\u0002", + "\u0002\u0002\u0441\u0003\u0002\u0002\u0002\u0002\u0443\u0003\u0002\u0002", + "\u0002\u0002\u0445\u0003\u0002\u0002\u0002\u0002\u0447\u0003\u0002\u0002", + "\u0002\u0002\u044b\u0003\u0002\u0002\u0002\u0002\u044d\u0003\u0002\u0002", + "\u0002\u0002\u044f\u0003\u0002\u0002\u0002\u0002\u0451\u0003\u0002\u0002", + "\u0002\u0002\u0453\u0003\u0002\u0002\u0002\u0002\u0455\u0003\u0002\u0002", + "\u0002\u0002\u0457\u0003\u0002\u0002\u0002\u0002\u0459\u0003\u0002\u0002", + "\u0002\u0002\u045b\u0003\u0002\u0002\u0002\u0002\u045d\u0003\u0002\u0002", + "\u0002\u0003\u045f\u0003\u0002\u0002\u0002\u0003\u0461\u0003\u0002\u0002", + "\u0002\u0003\u0465\u0003\u0002\u0002\u0002\u0003\u0467\u0003\u0002\u0002", + "\u0002\u0004\u046b\u0003\u0002\u0002\u0002\u0004\u046d\u0003\u0002\u0002", + "\u0002\u0004\u046f\u0003\u0002\u0002\u0002\u0005\u0471\u0003\u0002\u0002", + "\u0002\u0005\u0473\u0003\u0002\u0002\u0002\u0005\u0475\u0003\u0002\u0002", + "\u0002\u0005\u0477\u0003\u0002\u0002\u0002\u0006\u0479\u0003\u0002\u0002", + "\u0002\u0006\u047b\u0003\u0002\u0002\u0002\u0007\u047d\u0003\u0002\u0002", + "\u0002\t\u047f\u0003\u0002\u0002\u0002\u000b\u0481\u0003\u0002\u0002", + "\u0002\r\u0483\u0003\u0002\u0002\u0002\u000f\u0485\u0003\u0002\u0002", + "\u0002\u0011\u0487\u0003\u0002\u0002\u0002\u0013\u0489\u0003\u0002\u0002", + "\u0002\u0015\u048b\u0003\u0002\u0002\u0002\u0017\u048d\u0003\u0002\u0002", + "\u0002\u0019\u048f\u0003\u0002\u0002\u0002\u001b\u0491\u0003\u0002\u0002", + "\u0002\u001d\u0493\u0003\u0002\u0002\u0002\u001f\u0495\u0003\u0002\u0002", + "\u0002!\u0497\u0003\u0002\u0002\u0002#\u0499\u0003\u0002\u0002\u0002", + "%\u049b\u0003\u0002\u0002\u0002\'\u049d\u0003\u0002\u0002\u0002)\u049f", + "\u0003\u0002\u0002\u0002+\u04a2\u0003\u0002\u0002\u0002-\u04a5\u0003", + "\u0002\u0002\u0002/\u04a8\u0003\u0002\u0002\u00021\u04ab\u0003\u0002", + "\u0002\u00023\u04ae\u0003\u0002\u0002\u00025\u04b1\u0003\u0002\u0002", + "\u00027\u04b4\u0003\u0002\u0002\u00029\u04b7\u0003\u0002\u0002\u0002", + ";\u04ba\u0003\u0002\u0002\u0002=\u04bc\u0003\u0002\u0002\u0002?\u04d6", + "\u0003\u0002\u0002\u0002A\u04e1\u0003\u0002\u0002\u0002C\u04f1\u0003", + "\u0002\u0002\u0002E\u04f3\u0003\u0002\u0002\u0002G\u04f5\u0003\u0002", + "\u0002\u0002I\u04f7\u0003\u0002\u0002\u0002K\u04fb\u0003\u0002\u0002", + "\u0002M\u0503\u0003\u0002\u0002\u0002O\u050b\u0003\u0002\u0002\u0002", + "Q\u050f\u0003\u0002\u0002\u0002S\u0513\u0003\u0002\u0002\u0002U\u0519", + "\u0003\u0002\u0002\u0002W\u051c\u0003\u0002\u0002\u0002Y\u0520\u0003", + "\u0002\u0002\u0002[\u052b\u0003\u0002\u0002\u0002]\u0530\u0003\u0002", + "\u0002\u0002_\u0535\u0003\u0002\u0002\u0002a\u053a\u0003\u0002\u0002", + "\u0002c\u0540\u0003\u0002\u0002\u0002e\u0548\u0003\u0002\u0002\u0002", + "g\u054f\u0003\u0002\u0002\u0002i\u055a\u0003\u0002\u0002\u0002k\u0561", + "\u0003\u0002\u0002\u0002m\u0571\u0003\u0002\u0002\u0002o\u057e\u0003", + "\u0002\u0002\u0002q\u058b\u0003\u0002\u0002\u0002s\u0598\u0003\u0002", + "\u0002\u0002u\u05aa\u0003\u0002\u0002\u0002w\u05b7\u0003\u0002\u0002", + "\u0002y\u05bf\u0003\u0002\u0002\u0002{\u05ca\u0003\u0002\u0002\u0002", + "}\u05cf\u0003\u0002\u0002\u0002\u007f\u05d8\u0003\u0002\u0002\u0002", + "\u0081\u05db\u0003\u0002\u0002\u0002\u0083\u05e0\u0003\u0002\u0002\u0002", + "\u0085\u05e7\u0003\u0002\u0002\u0002\u0087\u05ed\u0003\u0002\u0002\u0002", + "\u0089\u05f3\u0003\u0002\u0002\u0002\u008b\u05f7\u0003\u0002\u0002\u0002", + "\u008d\u05ff\u0003\u0002\u0002\u0002\u008f\u0604\u0003\u0002\u0002\u0002", + "\u0091\u060a\u0003\u0002\u0002\u0002\u0093\u0610\u0003\u0002\u0002\u0002", + "\u0095\u0617\u0003\u0002\u0002\u0002\u0097\u061a\u0003\u0002\u0002\u0002", + "\u0099\u0624\u0003\u0002\u0002\u0002\u009b\u062e\u0003\u0002\u0002\u0002", + "\u009d\u0633\u0003\u0002\u0002\u0002\u009f\u063b\u0003\u0002\u0002\u0002", + "\u00a1\u0643\u0003\u0002\u0002\u0002\u00a3\u0649\u0003\u0002\u0002\u0002", + "\u00a5\u0653\u0003\u0002\u0002\u0002\u00a7\u0662\u0003\u0002\u0002\u0002", + "\u00a9\u0666\u0003\u0002\u0002\u0002\u00ab\u066b\u0003\u0002\u0002\u0002", + "\u00ad\u0672\u0003\u0002\u0002\u0002\u00af\u0675\u0003\u0002\u0002\u0002", + "\u00b1\u067a\u0003\u0002\u0002\u0002\u00b3\u067d\u0003\u0002\u0002\u0002", + "\u00b5\u0683\u0003\u0002\u0002\u0002\u00b7\u068b\u0003\u0002\u0002\u0002", + "\u00b9\u0693\u0003\u0002\u0002\u0002\u00bb\u069e\u0003\u0002\u0002\u0002", + "\u00bd\u06a8\u0003\u0002\u0002\u0002\u00bf\u06af\u0003\u0002\u0002\u0002", + "\u00c1\u06bc\u0003\u0002\u0002\u0002\u00c3\u06c1\u0003\u0002\u0002\u0002", + "\u00c5\u06cb\u0003\u0002\u0002\u0002\u00c7\u06d1\u0003\u0002\u0002\u0002", + "\u00c9\u06d6\u0003\u0002\u0002\u0002\u00cb\u06d9\u0003\u0002\u0002\u0002", + "\u00cd\u06e2\u0003\u0002\u0002\u0002\u00cf\u06e7\u0003\u0002\u0002\u0002", + "\u00d1\u06ed\u0003\u0002\u0002\u0002\u00d3\u06f4\u0003\u0002\u0002\u0002", + "\u00d5\u06f9\u0003\u0002\u0002\u0002\u00d7\u06ff\u0003\u0002\u0002\u0002", + "\u00d9\u0708\u0003\u0002\u0002\u0002\u00db\u070d\u0003\u0002\u0002\u0002", + "\u00dd\u0713\u0003\u0002\u0002\u0002\u00df\u071a\u0003\u0002\u0002\u0002", + "\u00e1\u071f\u0003\u0002\u0002\u0002\u00e3\u072d\u0003\u0002\u0002\u0002", + "\u00e5\u0734\u0003\u0002\u0002\u0002\u00e7\u073e\u0003\u0002\u0002\u0002", + "\u00e9\u074b\u0003\u0002\u0002\u0002\u00eb\u0751\u0003\u0002\u0002\u0002", + "\u00ed\u0760\u0003\u0002\u0002\u0002\u00ef\u0767\u0003\u0002\u0002\u0002", + "\u00f1\u076c\u0003\u0002\u0002\u0002\u00f3\u0772\u0003\u0002\u0002\u0002", + "\u00f5\u0778\u0003\u0002\u0002\u0002\u00f7\u077b\u0003\u0002\u0002\u0002", + "\u00f9\u0782\u0003\u0002\u0002\u0002\u00fb\u0787\u0003\u0002\u0002\u0002", + "\u00fd\u078c\u0003\u0002\u0002\u0002\u00ff\u0791\u0003\u0002\u0002\u0002", + "\u0101\u0799\u0003\u0002\u0002\u0002\u0103\u07a1\u0003\u0002\u0002\u0002", + "\u0105\u07a7\u0003\u0002\u0002\u0002\u0107\u07ac\u0003\u0002\u0002\u0002", + "\u0109\u07b5\u0003\u0002\u0002\u0002\u010b\u07bb\u0003\u0002\u0002\u0002", + "\u010d\u07c3\u0003\u0002\u0002\u0002\u010f\u07cb\u0003\u0002\u0002\u0002", + "\u0111\u07d1\u0003\u0002\u0002\u0002\u0113\u07da\u0003\u0002\u0002\u0002", + "\u0115\u07e1\u0003\u0002\u0002\u0002\u0117\u07e8\u0003\u0002\u0002\u0002", + "\u0119\u07ec\u0003\u0002\u0002\u0002\u011b\u07f2\u0003\u0002\u0002\u0002", + "\u011d\u07f8\u0003\u0002\u0002\u0002\u011f\u0802\u0003\u0002\u0002\u0002", + "\u0121\u0807\u0003\u0002\u0002\u0002\u0123\u080d\u0003\u0002\u0002\u0002", + "\u0125\u0814\u0003\u0002\u0002\u0002\u0127\u081e\u0003\u0002\u0002\u0002", + "\u0129\u0829\u0003\u0002\u0002\u0002\u012b\u082c\u0003\u0002\u0002\u0002", + "\u012d\u0836\u0003\u0002\u0002\u0002\u012f\u083f\u0003\u0002\u0002\u0002", + "\u0131\u0846\u0003\u0002\u0002\u0002\u0133\u084c\u0003\u0002\u0002\u0002", + "\u0135\u084f\u0003\u0002\u0002\u0002\u0137\u0855\u0003\u0002\u0002\u0002", + "\u0139\u085c\u0003\u0002\u0002\u0002\u013b\u0864\u0003\u0002\u0002\u0002", + "\u013d\u086d\u0003\u0002\u0002\u0002\u013f\u0875\u0003\u0002\u0002\u0002", + "\u0141\u087b\u0003\u0002\u0002\u0002\u0143\u088b\u0003\u0002\u0002\u0002", + "\u0145\u0896\u0003\u0002\u0002\u0002\u0147\u089c\u0003\u0002\u0002\u0002", + "\u0149\u08a2\u0003\u0002\u0002\u0002\u014b\u08aa\u0003\u0002\u0002\u0002", + "\u014d\u08b2\u0003\u0002\u0002\u0002\u014f\u08bb\u0003\u0002\u0002\u0002", + "\u0151\u08c2\u0003\u0002\u0002\u0002\u0153\u08cc\u0003\u0002\u0002\u0002", + "\u0155\u08da\u0003\u0002\u0002\u0002\u0157\u08e5\u0003\u0002\u0002\u0002", + "\u0159\u08f1\u0003\u0002\u0002\u0002\u015b\u08f9\u0003\u0002\u0002\u0002", + "\u015d\u0902\u0003\u0002\u0002\u0002\u015f\u090d\u0003\u0002\u0002\u0002", + "\u0161\u0912\u0003\u0002\u0002\u0002\u0163\u0917\u0003\u0002\u0002\u0002", + "\u0165\u091b\u0003\u0002\u0002\u0002\u0167\u0922\u0003\u0002\u0002\u0002", + "\u0169\u0928\u0003\u0002\u0002\u0002\u016b\u092d\u0003\u0002\u0002\u0002", + "\u016d\u0936\u0003\u0002\u0002\u0002\u016f\u093a\u0003\u0002\u0002\u0002", + "\u0171\u0945\u0003\u0002\u0002\u0002\u0173\u094d\u0003\u0002\u0002\u0002", + "\u0175\u0956\u0003\u0002\u0002\u0002\u0177\u095f\u0003\u0002\u0002\u0002", + "\u0179\u0967\u0003\u0002\u0002\u0002\u017b\u096e\u0003\u0002\u0002\u0002", + "\u017d\u0978\u0003\u0002\u0002\u0002\u017f\u0983\u0003\u0002\u0002\u0002", + "\u0181\u098e\u0003\u0002\u0002\u0002\u0183\u0996\u0003\u0002\u0002\u0002", + "\u0185\u099e\u0003\u0002\u0002\u0002\u0187\u09a7\u0003\u0002\u0002\u0002", + "\u0189\u09ae\u0003\u0002\u0002\u0002\u018b\u09b5\u0003\u0002\u0002\u0002", + "\u018d\u09ba\u0003\u0002\u0002\u0002\u018f\u09bf\u0003\u0002\u0002\u0002", + "\u0191\u09c6\u0003\u0002\u0002\u0002\u0193\u09cf\u0003\u0002\u0002\u0002", + "\u0195\u09d9\u0003\u0002\u0002\u0002\u0197\u09de\u0003\u0002\u0002\u0002", + "\u0199\u09e5\u0003\u0002\u0002\u0002\u019b\u09eb\u0003\u0002\u0002\u0002", + "\u019d\u09f3\u0003\u0002\u0002\u0002\u019f\u09fd\u0003\u0002\u0002\u0002", + "\u01a1\u0a07\u0003\u0002\u0002\u0002\u01a3\u0a0f\u0003\u0002\u0002\u0002", + "\u01a5\u0a17\u0003\u0002\u0002\u0002\u01a7\u0a21\u0003\u0002\u0002\u0002", + "\u01a9\u0a2a\u0003\u0002\u0002\u0002\u01ab\u0a31\u0003\u0002\u0002\u0002", + "\u01ad\u0a37\u0003\u0002\u0002\u0002\u01af\u0a41\u0003\u0002\u0002\u0002", + "\u01b1\u0a47\u0003\u0002\u0002\u0002\u01b3\u0a4f\u0003\u0002\u0002\u0002", + "\u01b5\u0a58\u0003\u0002\u0002\u0002\u01b7\u0a62\u0003\u0002\u0002\u0002", + "\u01b9\u0a69\u0003\u0002\u0002\u0002\u01bb\u0a71\u0003\u0002\u0002\u0002", + "\u01bd\u0a79\u0003\u0002\u0002\u0002\u01bf\u0a80\u0003\u0002\u0002\u0002", + "\u01c1\u0a85\u0003\u0002\u0002\u0002\u01c3\u0a8a\u0003\u0002\u0002\u0002", + "\u01c5\u0a93\u0003\u0002\u0002\u0002\u01c7\u0a96\u0003\u0002\u0002\u0002", + "\u01c9\u0aa0\u0003\u0002\u0002\u0002\u01cb\u0aaa\u0003\u0002\u0002\u0002", + "\u01cd\u0ab3\u0003\u0002\u0002\u0002\u01cf\u0abd\u0003\u0002\u0002\u0002", + "\u01d1\u0ac7\u0003\u0002\u0002\u0002\u01d3\u0acd\u0003\u0002\u0002\u0002", + "\u01d5\u0ad5\u0003\u0002\u0002\u0002\u01d7\u0add\u0003\u0002\u0002\u0002", + "\u01d9\u0ae6\u0003\u0002\u0002\u0002\u01db\u0aed\u0003\u0002\u0002\u0002", + "\u01dd\u0af9\u0003\u0002\u0002\u0002\u01df\u0b00\u0003\u0002\u0002\u0002", + "\u01e1\u0b08\u0003\u0002\u0002\u0002\u01e3\u0b10\u0003\u0002\u0002\u0002", + "\u01e5\u0b1a\u0003\u0002\u0002\u0002\u01e7\u0b1e\u0003\u0002\u0002\u0002", + "\u01e9\u0b24\u0003\u0002\u0002\u0002\u01eb\u0b2d\u0003\u0002\u0002\u0002", + "\u01ed\u0b33\u0003\u0002\u0002\u0002\u01ef\u0b38\u0003\u0002\u0002\u0002", + "\u01f1\u0b42\u0003\u0002\u0002\u0002\u01f3\u0b48\u0003\u0002\u0002\u0002", + "\u01f5\u0b4f\u0003\u0002\u0002\u0002\u01f7\u0b54\u0003\u0002\u0002\u0002", + "\u01f9\u0b5a\u0003\u0002\u0002\u0002\u01fb\u0b63\u0003\u0002\u0002\u0002", + "\u01fd\u0b68\u0003\u0002\u0002\u0002\u01ff\u0b70\u0003\u0002\u0002\u0002", + "\u0201\u0b76\u0003\u0002\u0002\u0002\u0203\u0b83\u0003\u0002\u0002\u0002", + "\u0205\u0b8c\u0003\u0002\u0002\u0002\u0207\u0b93\u0003\u0002\u0002\u0002", + "\u0209\u0b9c\u0003\u0002\u0002\u0002\u020b\u0ba1\u0003\u0002\u0002\u0002", + "\u020d\u0ba7\u0003\u0002\u0002\u0002\u020f\u0bac\u0003\u0002\u0002\u0002", + "\u0211\u0bb1\u0003\u0002\u0002\u0002\u0213\u0bb7\u0003\u0002\u0002\u0002", + "\u0215\u0bbc\u0003\u0002\u0002\u0002\u0217\u0bbf\u0003\u0002\u0002\u0002", + "\u0219\u0bc7\u0003\u0002\u0002\u0002\u021b\u0bce\u0003\u0002\u0002\u0002", + "\u021d\u0bd5\u0003\u0002\u0002\u0002\u021f\u0bdb\u0003\u0002\u0002\u0002", + "\u0221\u0be2\u0003\u0002\u0002\u0002\u0223\u0be5\u0003\u0002\u0002\u0002", + "\u0225\u0be9\u0003\u0002\u0002\u0002\u0227\u0bee\u0003\u0002\u0002\u0002", + "\u0229\u0bf7\u0003\u0002\u0002\u0002\u022b\u0bfe\u0003\u0002\u0002\u0002", + "\u022d\u0c06\u0003\u0002\u0002\u0002\u022f\u0c0c\u0003\u0002\u0002\u0002", + "\u0231\u0c12\u0003\u0002\u0002\u0002\u0233\u0c19\u0003\u0002\u0002\u0002", + "\u0235\u0c21\u0003\u0002\u0002\u0002\u0237\u0c2b\u0003\u0002\u0002\u0002", + "\u0239\u0c33\u0003\u0002\u0002\u0002\u023b\u0c3c\u0003\u0002\u0002\u0002", + "\u023d\u0c42\u0003\u0002\u0002\u0002\u023f\u0c4c\u0003\u0002\u0002\u0002", + "\u0241\u0c54\u0003\u0002\u0002\u0002\u0243\u0c5d\u0003\u0002\u0002\u0002", + "\u0245\u0c66\u0003\u0002\u0002\u0002\u0247\u0c6c\u0003\u0002\u0002\u0002", + "\u0249\u0c77\u0003\u0002\u0002\u0002\u024b\u0c82\u0003\u0002\u0002\u0002", + "\u024d\u0c8c\u0003\u0002\u0002\u0002\u024f\u0c94\u0003\u0002\u0002\u0002", + "\u0251\u0c9a\u0003\u0002\u0002\u0002\u0253\u0ca0\u0003\u0002\u0002\u0002", + "\u0255\u0ca5\u0003\u0002\u0002\u0002\u0257\u0cae\u0003\u0002\u0002\u0002", + "\u0259\u0cb6\u0003\u0002\u0002\u0002\u025b\u0cc0\u0003\u0002\u0002\u0002", + "\u025d\u0cc4\u0003\u0002\u0002\u0002\u025f\u0ccc\u0003\u0002\u0002\u0002", + "\u0261\u0cd4\u0003\u0002\u0002\u0002\u0263\u0cdd\u0003\u0002\u0002\u0002", + "\u0265\u0ce5\u0003\u0002\u0002\u0002\u0267\u0cec\u0003\u0002\u0002\u0002", + "\u0269\u0cf7\u0003\u0002\u0002\u0002\u026b\u0cff\u0003\u0002\u0002\u0002", + "\u026d\u0d07\u0003\u0002\u0002\u0002\u026f\u0d0d\u0003\u0002\u0002\u0002", + "\u0271\u0d15\u0003\u0002\u0002\u0002\u0273\u0d1e\u0003\u0002\u0002\u0002", + "\u0275\u0d26\u0003\u0002\u0002\u0002\u0277\u0d2d\u0003\u0002\u0002\u0002", + "\u0279\u0d32\u0003\u0002\u0002\u0002\u027b\u0d3b\u0003\u0002\u0002\u0002", + "\u027d\u0d40\u0003\u0002\u0002\u0002\u027f\u0d45\u0003\u0002\u0002\u0002", + "\u0281\u0d4f\u0003\u0002\u0002\u0002\u0283\u0d56\u0003\u0002\u0002\u0002", + "\u0285\u0d5d\u0003\u0002\u0002\u0002\u0287\u0d64\u0003\u0002\u0002\u0002", + "\u0289\u0d6b\u0003\u0002\u0002\u0002\u028b\u0d74\u0003\u0002\u0002\u0002", + "\u028d\u0d7d\u0003\u0002\u0002\u0002\u028f\u0d87\u0003\u0002\u0002\u0002", + "\u0291\u0d94\u0003\u0002\u0002\u0002\u0293\u0d9b\u0003\u0002\u0002\u0002", + "\u0295\u0da3\u0003\u0002\u0002\u0002\u0297\u0da7\u0003\u0002\u0002\u0002", + "\u0299\u0dad\u0003\u0002\u0002\u0002\u029b\u0db2\u0003\u0002\u0002\u0002", + "\u029d\u0db9\u0003\u0002\u0002\u0002\u029f\u0dc2\u0003\u0002\u0002\u0002", + "\u02a1\u0dc9\u0003\u0002\u0002\u0002\u02a3\u0dd4\u0003\u0002\u0002\u0002", + "\u02a5\u0dda\u0003\u0002\u0002\u0002\u02a7\u0de4\u0003\u0002\u0002\u0002", + "\u02a9\u0def\u0003\u0002\u0002\u0002\u02ab\u0df5\u0003\u0002\u0002\u0002", + "\u02ad\u0dfc\u0003\u0002\u0002\u0002\u02af\u0e04\u0003\u0002\u0002\u0002", + "\u02b1\u0e0b\u0003\u0002\u0002\u0002\u02b3\u0e11\u0003\u0002\u0002\u0002", + "\u02b5\u0e17\u0003\u0002\u0002\u0002\u02b7\u0e1e\u0003\u0002\u0002\u0002", + "\u02b9\u0e25\u0003\u0002\u0002\u0002\u02bb\u0e30\u0003\u0002\u0002\u0002", + "\u02bd\u0e35\u0003\u0002\u0002\u0002\u02bf\u0e3e\u0003\u0002\u0002\u0002", + "\u02c1\u0e48\u0003\u0002\u0002\u0002\u02c3\u0e4d\u0003\u0002\u0002\u0002", + "\u02c5\u0e59\u0003\u0002\u0002\u0002\u02c7\u0e61\u0003\u0002\u0002\u0002", + "\u02c9\u0e6a\u0003\u0002\u0002\u0002\u02cb\u0e72\u0003\u0002\u0002\u0002", + "\u02cd\u0e77\u0003\u0002\u0002\u0002\u02cf\u0e7d\u0003\u0002\u0002\u0002", + "\u02d1\u0e87\u0003\u0002\u0002\u0002\u02d3\u0e93\u0003\u0002\u0002\u0002", + "\u02d5\u0e9f\u0003\u0002\u0002\u0002\u02d7\u0ea7\u0003\u0002\u0002\u0002", + "\u02d9\u0eb0\u0003\u0002\u0002\u0002\u02db\u0eb9\u0003\u0002\u0002\u0002", + "\u02dd\u0ebf\u0003\u0002\u0002\u0002\u02df\u0ec6\u0003\u0002\u0002\u0002", + "\u02e1\u0ecd\u0003\u0002\u0002\u0002\u02e3\u0ed3\u0003\u0002\u0002\u0002", + "\u02e5\u0edc\u0003\u0002\u0002\u0002\u02e7\u0ee6\u0003\u0002\u0002\u0002", + "\u02e9\u0eee\u0003\u0002\u0002\u0002\u02eb\u0ef6\u0003\u0002\u0002\u0002", + "\u02ed\u0efb\u0003\u0002\u0002\u0002\u02ef\u0f04\u0003\u0002\u0002\u0002", + "\u02f1\u0f0f\u0003\u0002\u0002\u0002\u02f3\u0f17\u0003\u0002\u0002\u0002", + "\u02f5\u0f1c\u0003\u0002\u0002\u0002\u02f7\u0f24\u0003\u0002\u0002\u0002", + "\u02f9\u0f2a\u0003\u0002\u0002\u0002\u02fb\u0f2e\u0003\u0002\u0002\u0002", + "\u02fd\u0f33\u0003\u0002\u0002\u0002\u02ff\u0f37\u0003\u0002\u0002\u0002", + "\u0301\u0f3c\u0003\u0002\u0002\u0002\u0303\u0f44\u0003\u0002\u0002\u0002", + "\u0305\u0f4b\u0003\u0002\u0002\u0002\u0307\u0f4f\u0003\u0002\u0002\u0002", + "\u0309\u0f57\u0003\u0002\u0002\u0002\u030b\u0f5c\u0003\u0002\u0002\u0002", + "\u030d\u0f66\u0003\u0002\u0002\u0002\u030f\u0f6f\u0003\u0002\u0002\u0002", + "\u0311\u0f73\u0003\u0002\u0002\u0002\u0313\u0f7b\u0003\u0002\u0002\u0002", + "\u0315\u0f82\u0003\u0002\u0002\u0002\u0317\u0f8a\u0003\u0002\u0002\u0002", + "\u0319\u0f90\u0003\u0002\u0002\u0002\u031b\u0f99\u0003\u0002\u0002\u0002", + "\u031d\u0f9f\u0003\u0002\u0002\u0002\u031f\u0fa3\u0003\u0002\u0002\u0002", + "\u0321\u0fab\u0003\u0002\u0002\u0002\u0323\u0fb4\u0003\u0002\u0002\u0002", + "\u0325\u0fba\u0003\u0002\u0002\u0002\u0327\u0fc3\u0003\u0002\u0002\u0002", + "\u0329\u0fc9\u0003\u0002\u0002\u0002\u032b\u0fce\u0003\u0002\u0002\u0002", + "\u032d\u0fd5\u0003\u0002\u0002\u0002\u032f\u0fdd\u0003\u0002\u0002\u0002", + "\u0331\u0fe5\u0003\u0002\u0002\u0002\u0333\u0fee\u0003\u0002\u0002\u0002", + "\u0335\u0ff8\u0003\u0002\u0002\u0002\u0337\u0ffd\u0003\u0002\u0002\u0002", + "\u0339\u1001\u0003\u0002\u0002\u0002\u033b\u1007\u0003\u0002\u0002\u0002", + "\u033d\u1010\u0003\u0002\u0002\u0002\u033f\u101a\u0003\u0002\u0002\u0002", + "\u0341\u101f\u0003\u0002\u0002\u0002\u0343\u1029\u0003\u0002\u0002\u0002", + "\u0345\u102f\u0003\u0002\u0002\u0002\u0347\u1034\u0003\u0002\u0002\u0002", + "\u0349\u103b\u0003\u0002\u0002\u0002\u034b\u1043\u0003\u0002\u0002\u0002", + "\u034d\u1051\u0003\u0002\u0002\u0002\u034f\u105b\u0003\u0002\u0002\u0002", + "\u0351\u1066\u0003\u0002\u0002\u0002\u0353\u1070\u0003\u0002\u0002\u0002", + "\u0355\u107a\u0003\u0002\u0002\u0002\u0357\u1083\u0003\u0002\u0002\u0002", + "\u0359\u1089\u0003\u0002\u0002\u0002\u035b\u1091\u0003\u0002\u0002\u0002", + "\u035d\u109e\u0003\u0002\u0002\u0002\u035f\u10a3\u0003\u0002\u0002\u0002", + "\u0361\u10ab\u0003\u0002\u0002\u0002\u0363\u10b2\u0003\u0002\u0002\u0002", + "\u0365\u10b9\u0003\u0002\u0002\u0002\u0367\u10c4\u0003\u0002\u0002\u0002", + "\u0369\u10ce\u0003\u0002\u0002\u0002\u036b\u10d5\u0003\u0002\u0002\u0002", + "\u036d\u10dc\u0003\u0002\u0002\u0002\u036f\u10e4\u0003\u0002\u0002\u0002", + "\u0371\u10ec\u0003\u0002\u0002\u0002\u0373\u10f6\u0003\u0002\u0002\u0002", + "\u0375\u10fd\u0003\u0002\u0002\u0002\u0377\u1104\u0003\u0002\u0002\u0002", + "\u0379\u110b\u0003\u0002\u0002\u0002\u037b\u1117\u0003\u0002\u0002\u0002", + "\u037d\u111b\u0003\u0002\u0002\u0002\u037f\u111f\u0003\u0002\u0002\u0002", + "\u0381\u1125\u0003\u0002\u0002\u0002\u0383\u1132\u0003\u0002\u0002\u0002", + "\u0385\u113e\u0003\u0002\u0002\u0002\u0387\u1142\u0003\u0002\u0002\u0002", + "\u0389\u1146\u0003\u0002\u0002\u0002\u038b\u114f\u0003\u0002\u0002\u0002", + "\u038d\u1157\u0003\u0002\u0002\u0002\u038f\u1162\u0003\u0002\u0002\u0002", + "\u0391\u1168\u0003\u0002\u0002\u0002\u0393\u1170\u0003\u0002\u0002\u0002", + "\u0395\u1179\u0003\u0002\u0002\u0002\u0397\u117d\u0003\u0002\u0002\u0002", + "\u0399\u1185\u0003\u0002\u0002\u0002\u039b\u1190\u0003\u0002\u0002\u0002", + "\u039d\u1199\u0003\u0002\u0002\u0002\u039f\u119e\u0003\u0002\u0002\u0002", + "\u03a1\u11a5\u0003\u0002\u0002\u0002\u03a3\u11aa\u0003\u0002\u0002\u0002", + "\u03a5\u11b1\u0003\u0002\u0002\u0002\u03a7\u11b6\u0003\u0002\u0002\u0002", + "\u03a9\u11bf\u0003\u0002\u0002\u0002\u03ab\u11c4\u0003\u0002\u0002\u0002", + "\u03ad\u11d0\u0003\u0002\u0002\u0002\u03af\u11db\u0003\u0002\u0002\u0002", + "\u03b1\u11e4\u0003\u0002\u0002\u0002\u03b3\u11ec\u0003\u0002\u0002\u0002", + "\u03b5\u11fa\u0003\u0002\u0002\u0002\u03b7\u1202\u0003\u0002\u0002\u0002", + "\u03b9\u120d\u0003\u0002\u0002\u0002\u03bb\u1214\u0003\u0002\u0002\u0002", + "\u03bd\u121b\u0003\u0002\u0002\u0002\u03bf\u1222\u0003\u0002\u0002\u0002", + "\u03c1\u1229\u0003\u0002\u0002\u0002\u03c3\u122d\u0003\u0002\u0002\u0002", + "\u03c5\u1231\u0003\u0002\u0002\u0002\u03c7\u1236\u0003\u0002\u0002\u0002", + "\u03c9\u123b\u0003\u0002\u0002\u0002\u03cb\u1243\u0003\u0002\u0002\u0002", + "\u03cd\u1249\u0003\u0002\u0002\u0002\u03cf\u1253\u0003\u0002\u0002\u0002", + "\u03d1\u1258\u0003\u0002\u0002\u0002\u03d3\u126c\u0003\u0002\u0002\u0002", + "\u03d5\u127e\u0003\u0002\u0002\u0002\u03d7\u1284\u0003\u0002\u0002\u0002", + "\u03d9\u1291\u0003\u0002\u0002\u0002\u03db\u129c\u0003\u0002\u0002\u0002", + "\u03dd\u12a2\u0003\u0002\u0002\u0002\u03df\u12ab\u0003\u0002\u0002\u0002", + "\u03e1\u12b3\u0003\u0002\u0002\u0002\u03e3\u12b7\u0003\u0002\u0002\u0002", + "\u03e5\u12c3\u0003\u0002\u0002\u0002\u03e7\u12cb\u0003\u0002\u0002\u0002", + "\u03e9\u12d1\u0003\u0002\u0002\u0002\u03eb\u12d7\u0003\u0002\u0002\u0002", + "\u03ed\u12df\u0003\u0002\u0002\u0002\u03ef\u12e7\u0003\u0002\u0002\u0002", + "\u03f1\u12ed\u0003\u0002\u0002\u0002\u03f3\u12f2\u0003\u0002\u0002\u0002", + "\u03f5\u12f9\u0003\u0002\u0002\u0002\u03f7\u12ff\u0003\u0002\u0002\u0002", + "\u03f9\u1305\u0003\u0002\u0002\u0002\u03fb\u130e\u0003\u0002\u0002\u0002", + "\u03fd\u1314\u0003\u0002\u0002\u0002\u03ff\u1318\u0003\u0002\u0002\u0002", + "\u0401\u131d\u0003\u0002\u0002\u0002\u0403\u1324\u0003\u0002\u0002\u0002", + "\u0405\u132c\u0003\u0002\u0002\u0002\u0407\u1336\u0003\u0002\u0002\u0002", + "\u0409\u133d\u0003\u0002\u0002\u0002\u040b\u1342\u0003\u0002\u0002\u0002", + "\u040d\u1347\u0003\u0002\u0002\u0002\u040f\u1354\u0003\u0002\u0002\u0002", + "\u0411\u1358\u0003\u0002\u0002\u0002\u0413\u135c\u0003\u0002\u0002\u0002", + "\u0415\u135e\u0003\u0002\u0002\u0002\u0417\u1361\u0003\u0002\u0002\u0002", + "\u0419\u136a\u0003\u0002\u0002\u0002\u041b\u136d\u0003\u0002\u0002\u0002", + "\u041d\u1376\u0003\u0002\u0002\u0002\u041f\u137a\u0003\u0002\u0002\u0002", + "\u0421\u137e\u0003\u0002\u0002\u0002\u0423\u1382\u0003\u0002\u0002\u0002", + "\u0425\u1386\u0003\u0002\u0002\u0002\u0427\u1389\u0003\u0002\u0002\u0002", + "\u0429\u1392\u0003\u0002\u0002\u0002\u042b\u1398\u0003\u0002\u0002\u0002", + "\u042d\u139b\u0003\u0002\u0002\u0002\u042f\u139f\u0003\u0002\u0002\u0002", + "\u0431\u13a8\u0003\u0002\u0002\u0002\u0433\u13af\u0003\u0002\u0002\u0002", + "\u0435\u13b2\u0003\u0002\u0002\u0002\u0437\u13ba\u0003\u0002\u0002\u0002", + "\u0439\u13bd\u0003\u0002\u0002\u0002\u043b\u13c0\u0003\u0002\u0002\u0002", + "\u043d\u13c3\u0003\u0002\u0002\u0002\u043f\u13cb\u0003\u0002\u0002\u0002", + "\u0441\u13ce\u0003\u0002\u0002\u0002\u0443\u13d1\u0003\u0002\u0002\u0002", + "\u0445\u13d3\u0003\u0002\u0002\u0002\u0447\u13f5\u0003\u0002\u0002\u0002", + "\u0449\u13f8\u0003\u0002\u0002\u0002\u044b\u13fc\u0003\u0002\u0002\u0002", + "\u044d\u1404\u0003\u0002\u0002\u0002\u044f\u1414\u0003\u0002\u0002\u0002", + "\u0451\u141f\u0003\u0002\u0002\u0002\u0453\u1423\u0003\u0002\u0002\u0002", + "\u0455\u142e\u0003\u0002\u0002\u0002\u0457\u1455\u0003\u0002\u0002\u0002", + "\u0459\u1488\u0003\u0002\u0002\u0002\u045b\u14a0\u0003\u0002\u0002\u0002", + "\u045d\u14a3\u0003\u0002\u0002\u0002\u045f\u14a5\u0003\u0002\u0002\u0002", + "\u0461\u14aa\u0003\u0002\u0002\u0002\u0463\u14c9\u0003\u0002\u0002\u0002", + "\u0465\u14cc\u0003\u0002\u0002\u0002\u0467\u14d1\u0003\u0002\u0002\u0002", + "\u0469\u14de\u0003\u0002\u0002\u0002\u046b\u14e1\u0003\u0002\u0002\u0002", + "\u046d\u14e6\u0003\u0002\u0002\u0002\u046f\u14ec\u0003\u0002\u0002\u0002", + "\u0471\u14f1\u0003\u0002\u0002\u0002\u0473\u14f6\u0003\u0002\u0002\u0002", + "\u0475\u14fb\u0003\u0002\u0002\u0002\u0477\u1500\u0003\u0002\u0002\u0002", + "\u0479\u1511\u0003\u0002\u0002\u0002\u047b\u1513\u0003\u0002\u0002\u0002", + "\u047d\u047e\u0007&\u0002\u0002\u047e\b\u0003\u0002\u0002\u0002\u047f", + "\u0480\u0007*\u0002\u0002\u0480\n\u0003\u0002\u0002\u0002\u0481\u0482", + "\u0007+\u0002\u0002\u0482\f\u0003\u0002\u0002\u0002\u0483\u0484\u0007", + "]\u0002\u0002\u0484\u000e\u0003\u0002\u0002\u0002\u0485\u0486\u0007", + "_\u0002\u0002\u0486\u0010\u0003\u0002\u0002\u0002\u0487\u0488\u0007", + ".\u0002\u0002\u0488\u0012\u0003\u0002\u0002\u0002\u0489\u048a\u0007", + "=\u0002\u0002\u048a\u0014\u0003\u0002\u0002\u0002\u048b\u048c\u0007", + "<\u0002\u0002\u048c\u0016\u0003\u0002\u0002\u0002\u048d\u048e\u0007", + ",\u0002\u0002\u048e\u0018\u0003\u0002\u0002\u0002\u048f\u0490\u0007", + "?\u0002\u0002\u0490\u001a\u0003\u0002\u0002\u0002\u0491\u0492\u0007", + "0\u0002\u0002\u0492\u001c\u0003\u0002\u0002\u0002\u0493\u0494\u0007", + "-\u0002\u0002\u0494\u001e\u0003\u0002\u0002\u0002\u0495\u0496\u0007", + "/\u0002\u0002\u0496 \u0003\u0002\u0002\u0002\u0497\u0498\u00071\u0002", + "\u0002\u0498\"\u0003\u0002\u0002\u0002\u0499\u049a\u0007`\u0002\u0002", + "\u049a$\u0003\u0002\u0002\u0002\u049b\u049c\u0007>\u0002\u0002\u049c", + "&\u0003\u0002\u0002\u0002\u049d\u049e\u0007@\u0002\u0002\u049e(\u0003", + "\u0002\u0002\u0002\u049f\u04a0\u0007>\u0002\u0002\u04a0\u04a1\u0007", + ">\u0002\u0002\u04a1*\u0003\u0002\u0002\u0002\u04a2\u04a3\u0007@\u0002", + "\u0002\u04a3\u04a4\u0007@\u0002\u0002\u04a4,\u0003\u0002\u0002\u0002", + "\u04a5\u04a6\u0007<\u0002\u0002\u04a6\u04a7\u0007?\u0002\u0002\u04a7", + ".\u0003\u0002\u0002\u0002\u04a8\u04a9\u0007>\u0002\u0002\u04a9\u04aa", + "\u0007?\u0002\u0002\u04aa0\u0003\u0002\u0002\u0002\u04ab\u04ac\u0007", + "?\u0002\u0002\u04ac\u04ad\u0007@\u0002\u0002\u04ad2\u0003\u0002\u0002", + "\u0002\u04ae\u04af\u0007@\u0002\u0002\u04af\u04b0\u0007?\u0002\u0002", + "\u04b04\u0003\u0002\u0002\u0002\u04b1\u04b2\u00070\u0002\u0002\u04b2", + "\u04b3\u00070\u0002\u0002\u04b36\u0003\u0002\u0002\u0002\u04b4\u04b5", + "\u0007>\u0002\u0002\u04b5\u04b6\u0007@\u0002\u0002\u04b68\u0003\u0002", + "\u0002\u0002\u04b7\u04b8\u0007<\u0002\u0002\u04b8\u04b9\u0007<\u0002", + "\u0002\u04b9:\u0003\u0002\u0002\u0002\u04ba\u04bb\u0007\'\u0002\u0002", + "\u04bb<\u0003\u0002\u0002\u0002\u04bc\u04be\u0007&\u0002\u0002\u04bd", + "\u04bf\t\u0002\u0002\u0002\u04be\u04bd\u0003\u0002\u0002\u0002\u04bf", + "\u04c0\u0003\u0002\u0002\u0002\u04c0\u04be\u0003\u0002\u0002\u0002\u04c0", + "\u04c1\u0003\u0002\u0002\u0002\u04c1>\u0003\u0002\u0002\u0002\u04c2", + "\u04d2\u0005C \u0002\u04c3\u04c7\u0007-\u0002\u0002\u04c4\u04c5\u0007", + "/\u0002\u0002\u04c5\u04c7\u0006\u001e\u0002\u0002\u04c6\u04c3\u0003", + "\u0002\u0002\u0002\u04c6\u04c4\u0003\u0002\u0002\u0002\u04c7\u04c8\u0003", + "\u0002\u0002\u0002\u04c8\u04c6\u0003\u0002\u0002\u0002\u04c8\u04c9\u0003", + "\u0002\u0002\u0002\u04c9\u04cd\u0003\u0002\u0002\u0002\u04ca\u04ce\u0005", + "C \u0002\u04cb\u04cc\u00071\u0002\u0002\u04cc\u04ce\u0006\u001e\u0003", + "\u0002\u04cd\u04ca\u0003\u0002\u0002\u0002\u04cd\u04cb\u0003\u0002\u0002", + "\u0002\u04ce\u04d2\u0003\u0002\u0002\u0002\u04cf\u04d0\u00071\u0002", + "\u0002\u04d0\u04d2\u0006\u001e\u0004\u0002\u04d1\u04c2\u0003\u0002\u0002", + "\u0002\u04d1\u04c6\u0003\u0002\u0002\u0002\u04d1\u04cf\u0003\u0002\u0002", + "\u0002\u04d2\u04d3\u0003\u0002\u0002\u0002\u04d3\u04d1\u0003\u0002\u0002", + "\u0002\u04d3\u04d4\u0003\u0002\u0002\u0002\u04d4\u04d7\u0003\u0002\u0002", + "\u0002\u04d5\u04d7\t\u0003\u0002\u0002\u04d6\u04d1\u0003\u0002\u0002", + "\u0002\u04d6\u04d5\u0003\u0002\u0002\u0002\u04d7\u04d8\u0003\u0002\u0002", + "\u0002\u04d8\u04d9\b\u001e\u0002\u0002\u04d9@\u0003\u0002\u0002\u0002", + "\u04da\u04e0\u0005E!\u0002\u04db\u04dc\u0007/\u0002\u0002\u04dc\u04e0", + "\u0006\u001f\u0005\u0002\u04dd\u04de\u00071\u0002\u0002\u04de\u04e0", + "\u0006\u001f\u0006\u0002\u04df\u04da\u0003\u0002\u0002\u0002\u04df\u04db", + "\u0003\u0002\u0002\u0002\u04df\u04dd\u0003\u0002\u0002\u0002\u04e0\u04e3", + "\u0003\u0002\u0002\u0002\u04e1\u04df\u0003\u0002\u0002\u0002\u04e1\u04e2", + "\u0003\u0002\u0002\u0002\u04e2\u04e4\u0003\u0002\u0002\u0002\u04e3\u04e1", + "\u0003\u0002\u0002\u0002\u04e4\u04e6\u0005G\"\u0002\u04e5\u04e7\u0005", + "?\u001e\u0002\u04e6\u04e5\u0003\u0002\u0002\u0002\u04e6\u04e7\u0003", + "\u0002\u0002\u0002\u04e7\u04eb\u0003\u0002\u0002\u0002\u04e8\u04ec\u0007", + "-\u0002\u0002\u04e9\u04ea\u0007/\u0002\u0002\u04ea\u04ec\u0006\u001f", + "\u0007\u0002\u04eb\u04e8\u0003\u0002\u0002\u0002\u04eb\u04e9\u0003\u0002", + "\u0002\u0002\u04ec\u04ed\u0003\u0002\u0002\u0002\u04ed\u04eb\u0003\u0002", + "\u0002\u0002\u04ed\u04ee\u0003\u0002\u0002\u0002\u04ee\u04ef\u0003\u0002", + "\u0002\u0002\u04ef\u04f0\b\u001f\u0003\u0002\u04f0B\u0003\u0002\u0002", + "\u0002\u04f1\u04f2\t\u0004\u0002\u0002\u04f2D\u0003\u0002\u0002\u0002", + "\u04f3\u04f4\t\u0005\u0002\u0002\u04f4F\u0003\u0002\u0002\u0002\u04f5", + "\u04f6\t\u0006\u0002\u0002\u04f6H\u0003\u0002\u0002\u0002\u04f7\u04f8", + "\u0007C\u0002\u0002\u04f8\u04f9\u0007N\u0002\u0002\u04f9\u04fa\u0007", + "N\u0002\u0002\u04faJ\u0003\u0002\u0002\u0002\u04fb\u04fc\u0007C\u0002", + "\u0002\u04fc\u04fd\u0007P\u0002\u0002\u04fd\u04fe\u0007C\u0002\u0002", + "\u04fe\u04ff\u0007N\u0002\u0002\u04ff\u0500\u0007[\u0002\u0002\u0500", + "\u0501\u0007U\u0002\u0002\u0501\u0502\u0007G\u0002\u0002\u0502L\u0003", + "\u0002\u0002\u0002\u0503\u0504\u0007C\u0002\u0002\u0504\u0505\u0007", + "P\u0002\u0002\u0505\u0506\u0007C\u0002\u0002\u0506\u0507\u0007N\u0002", + "\u0002\u0507\u0508\u0007[\u0002\u0002\u0508\u0509\u0007\\\u0002\u0002", + "\u0509\u050a\u0007G\u0002\u0002\u050aN\u0003\u0002\u0002\u0002\u050b", + "\u050c\u0007C\u0002\u0002\u050c\u050d\u0007P\u0002\u0002\u050d\u050e", + "\u0007F\u0002\u0002\u050eP\u0003\u0002\u0002\u0002\u050f\u0510\u0007", + "C\u0002\u0002\u0510\u0511\u0007P\u0002\u0002\u0511\u0512\u0007[\u0002", + "\u0002\u0512R\u0003\u0002\u0002\u0002\u0513\u0514\u0007C\u0002\u0002", + "\u0514\u0515\u0007T\u0002\u0002\u0515\u0516\u0007T\u0002\u0002\u0516", + "\u0517\u0007C\u0002\u0002\u0517\u0518\u0007[\u0002\u0002\u0518T\u0003", + "\u0002\u0002\u0002\u0519\u051a\u0007C\u0002\u0002\u051a\u051b\u0007", + "U\u0002\u0002\u051bV\u0003\u0002\u0002\u0002\u051c\u051d\u0007C\u0002", + "\u0002\u051d\u051e\u0007U\u0002\u0002\u051e\u051f\u0007E\u0002\u0002", + "\u051fX\u0003\u0002\u0002\u0002\u0520\u0521\u0007C\u0002\u0002\u0521", + "\u0522\u0007U\u0002\u0002\u0522\u0523\u0007[\u0002\u0002\u0523\u0524", + "\u0007O\u0002\u0002\u0524\u0525\u0007O\u0002\u0002\u0525\u0526\u0007", + "G\u0002\u0002\u0526\u0527\u0007V\u0002\u0002\u0527\u0528\u0007T\u0002", + "\u0002\u0528\u0529\u0007K\u0002\u0002\u0529\u052a\u0007E\u0002\u0002", + "\u052aZ\u0003\u0002\u0002\u0002\u052b\u052c\u0007D\u0002\u0002\u052c", + "\u052d\u0007Q\u0002\u0002\u052d\u052e\u0007V\u0002\u0002\u052e\u052f", + "\u0007J\u0002\u0002\u052f\\\u0003\u0002\u0002\u0002\u0530\u0531\u0007", + "E\u0002\u0002\u0531\u0532\u0007C\u0002\u0002\u0532\u0533\u0007U\u0002", + "\u0002\u0533\u0534\u0007G\u0002\u0002\u0534^\u0003\u0002\u0002\u0002", + "\u0535\u0536\u0007E\u0002\u0002\u0536\u0537\u0007C\u0002\u0002\u0537", + "\u0538\u0007U\u0002\u0002\u0538\u0539\u0007V\u0002\u0002\u0539`\u0003", + "\u0002\u0002\u0002\u053a\u053b\u0007E\u0002\u0002\u053b\u053c\u0007", + "J\u0002\u0002\u053c\u053d\u0007G\u0002\u0002\u053d\u053e\u0007E\u0002", + "\u0002\u053e\u053f\u0007M\u0002\u0002\u053fb\u0003\u0002\u0002\u0002", + "\u0540\u0541\u0007E\u0002\u0002\u0541\u0542\u0007Q\u0002\u0002\u0542", + "\u0543\u0007N\u0002\u0002\u0543\u0544\u0007N\u0002\u0002\u0544\u0545", + "\u0007C\u0002\u0002\u0545\u0546\u0007V\u0002\u0002\u0546\u0547\u0007", + "G\u0002\u0002\u0547d\u0003\u0002\u0002\u0002\u0548\u0549\u0007E\u0002", + "\u0002\u0549\u054a\u0007Q\u0002\u0002\u054a\u054b\u0007N\u0002\u0002", + "\u054b\u054c\u0007W\u0002\u0002\u054c\u054d\u0007O\u0002\u0002\u054d", + "\u054e\u0007P\u0002\u0002\u054ef\u0003\u0002\u0002\u0002\u054f\u0550", + "\u0007E\u0002\u0002\u0550\u0551\u0007Q\u0002\u0002\u0551\u0552\u0007", + "P\u0002\u0002\u0552\u0553\u0007U\u0002\u0002\u0553\u0554\u0007V\u0002", + "\u0002\u0554\u0555\u0007T\u0002\u0002\u0555\u0556\u0007C\u0002\u0002", + "\u0556\u0557\u0007K\u0002\u0002\u0557\u0558\u0007P\u0002\u0002\u0558", + "\u0559\u0007V\u0002\u0002\u0559h\u0003\u0002\u0002\u0002\u055a\u055b", + "\u0007E\u0002\u0002\u055b\u055c\u0007T\u0002\u0002\u055c\u055d\u0007", + "G\u0002\u0002\u055d\u055e\u0007C\u0002\u0002\u055e\u055f\u0007V\u0002", + "\u0002\u055f\u0560\u0007G\u0002\u0002\u0560j\u0003\u0002\u0002\u0002", + "\u0561\u0562\u0007E\u0002\u0002\u0562\u0563\u0007W\u0002\u0002\u0563", + "\u0564\u0007T\u0002\u0002\u0564\u0565\u0007T\u0002\u0002\u0565\u0566", + "\u0007G\u0002\u0002\u0566\u0567\u0007P\u0002\u0002\u0567\u0568\u0007", + "V\u0002\u0002\u0568\u0569\u0007a\u0002\u0002\u0569\u056a\u0007E\u0002", + "\u0002\u056a\u056b\u0007C\u0002\u0002\u056b\u056c\u0007V\u0002\u0002", + "\u056c\u056d\u0007C\u0002\u0002\u056d\u056e\u0007N\u0002\u0002\u056e", + "\u056f\u0007Q\u0002\u0002\u056f\u0570\u0007I\u0002\u0002\u0570l\u0003", + "\u0002\u0002\u0002\u0571\u0572\u0007E\u0002\u0002\u0572\u0573\u0007", + "W\u0002\u0002\u0573\u0574\u0007T\u0002\u0002\u0574\u0575\u0007T\u0002", + "\u0002\u0575\u0576\u0007G\u0002\u0002\u0576\u0577\u0007P\u0002\u0002", + "\u0577\u0578\u0007V\u0002\u0002\u0578\u0579\u0007a\u0002\u0002\u0579", + "\u057a\u0007F\u0002\u0002\u057a\u057b\u0007C\u0002\u0002\u057b\u057c", + "\u0007V\u0002\u0002\u057c\u057d\u0007G\u0002\u0002\u057dn\u0003\u0002", + "\u0002\u0002\u057e\u057f\u0007E\u0002\u0002\u057f\u0580\u0007W\u0002", + "\u0002\u0580\u0581\u0007T\u0002\u0002\u0581\u0582\u0007T\u0002\u0002", + "\u0582\u0583\u0007G\u0002\u0002\u0583\u0584\u0007P\u0002\u0002\u0584", + "\u0585\u0007V\u0002\u0002\u0585\u0586\u0007a\u0002\u0002\u0586\u0587", + "\u0007T\u0002\u0002\u0587\u0588\u0007Q\u0002\u0002\u0588\u0589\u0007", + "N\u0002\u0002\u0589\u058a\u0007G\u0002\u0002\u058ap\u0003\u0002\u0002", + "\u0002\u058b\u058c\u0007E\u0002\u0002\u058c\u058d\u0007W\u0002\u0002", + "\u058d\u058e\u0007T\u0002\u0002\u058e\u058f\u0007T\u0002\u0002\u058f", + "\u0590\u0007G\u0002\u0002\u0590\u0591\u0007P\u0002\u0002\u0591\u0592", + "\u0007V\u0002\u0002\u0592\u0593\u0007a\u0002\u0002\u0593\u0594\u0007", + "V\u0002\u0002\u0594\u0595\u0007K\u0002\u0002\u0595\u0596\u0007O\u0002", + "\u0002\u0596\u0597\u0007G\u0002\u0002\u0597r\u0003\u0002\u0002\u0002", + "\u0598\u0599\u0007E\u0002\u0002\u0599\u059a\u0007W\u0002\u0002\u059a", + "\u059b\u0007T\u0002\u0002\u059b\u059c\u0007T\u0002\u0002\u059c\u059d", + "\u0007G\u0002\u0002\u059d\u059e\u0007P\u0002\u0002\u059e\u059f\u0007", + "V\u0002\u0002\u059f\u05a0\u0007a\u0002\u0002\u05a0\u05a1\u0007V\u0002", + "\u0002\u05a1\u05a2\u0007K\u0002\u0002\u05a2\u05a3\u0007O\u0002\u0002", + "\u05a3\u05a4\u0007G\u0002\u0002\u05a4\u05a5\u0007U\u0002\u0002\u05a5", + "\u05a6\u0007V\u0002\u0002\u05a6\u05a7\u0007C\u0002\u0002\u05a7\u05a8", + "\u0007O\u0002\u0002\u05a8\u05a9\u0007R\u0002\u0002\u05a9t\u0003\u0002", + "\u0002\u0002\u05aa\u05ab\u0007E\u0002\u0002\u05ab\u05ac\u0007W\u0002", + "\u0002\u05ac\u05ad\u0007T\u0002\u0002\u05ad\u05ae\u0007T\u0002\u0002", + "\u05ae\u05af\u0007G\u0002\u0002\u05af\u05b0\u0007P\u0002\u0002\u05b0", + "\u05b1\u0007V\u0002\u0002\u05b1\u05b2\u0007a\u0002\u0002\u05b2\u05b3", + "\u0007W\u0002\u0002\u05b3\u05b4\u0007U\u0002\u0002\u05b4\u05b5\u0007", + "G\u0002\u0002\u05b5\u05b6\u0007T\u0002\u0002\u05b6v\u0003\u0002\u0002", + "\u0002\u05b7\u05b8\u0007F\u0002\u0002\u05b8\u05b9\u0007G\u0002\u0002", + "\u05b9\u05ba\u0007H\u0002\u0002\u05ba\u05bb\u0007C\u0002\u0002\u05bb", + "\u05bc\u0007W\u0002\u0002\u05bc\u05bd\u0007N\u0002\u0002\u05bd\u05be", + "\u0007V\u0002\u0002\u05bex\u0003\u0002\u0002\u0002\u05bf\u05c0\u0007", + "F\u0002\u0002\u05c0\u05c1\u0007G\u0002\u0002\u05c1\u05c2\u0007H\u0002", + "\u0002\u05c2\u05c3\u0007G\u0002\u0002\u05c3\u05c4\u0007T\u0002\u0002", + "\u05c4\u05c5\u0007T\u0002\u0002\u05c5\u05c6\u0007C\u0002\u0002\u05c6", + "\u05c7\u0007D\u0002\u0002\u05c7\u05c8\u0007N\u0002\u0002\u05c8\u05c9", + "\u0007G\u0002\u0002\u05c9z\u0003\u0002\u0002\u0002\u05ca\u05cb\u0007", + "F\u0002\u0002\u05cb\u05cc\u0007G\u0002\u0002\u05cc\u05cd\u0007U\u0002", + "\u0002\u05cd\u05ce\u0007E\u0002\u0002\u05ce|\u0003\u0002\u0002\u0002", + "\u05cf\u05d0\u0007F\u0002\u0002\u05d0\u05d1\u0007K\u0002\u0002\u05d1", + "\u05d2\u0007U\u0002\u0002\u05d2\u05d3\u0007V\u0002\u0002\u05d3\u05d4", + "\u0007K\u0002\u0002\u05d4\u05d5\u0007P\u0002\u0002\u05d5\u05d6\u0007", + "E\u0002\u0002\u05d6\u05d7\u0007V\u0002\u0002\u05d7~\u0003\u0002\u0002", + "\u0002\u05d8\u05d9\u0007F\u0002\u0002\u05d9\u05da\u0007Q\u0002\u0002", + "\u05da\u0080\u0003\u0002\u0002\u0002\u05db\u05dc\u0007G\u0002\u0002", + "\u05dc\u05dd\u0007N\u0002\u0002\u05dd\u05de\u0007U\u0002\u0002\u05de", + "\u05df\u0007G\u0002\u0002\u05df\u0082\u0003\u0002\u0002\u0002\u05e0", + "\u05e1\u0007G\u0002\u0002\u05e1\u05e2\u0007Z\u0002\u0002\u05e2\u05e3", + "\u0007E\u0002\u0002\u05e3\u05e4\u0007G\u0002\u0002\u05e4\u05e5\u0007", + "R\u0002\u0002\u05e5\u05e6\u0007V\u0002\u0002\u05e6\u0084\u0003\u0002", + "\u0002\u0002\u05e7\u05e8\u0007H\u0002\u0002\u05e8\u05e9\u0007C\u0002", + "\u0002\u05e9\u05ea\u0007N\u0002\u0002\u05ea\u05eb\u0007U\u0002\u0002", + "\u05eb\u05ec\u0007G\u0002\u0002\u05ec\u0086\u0003\u0002\u0002\u0002", + "\u05ed\u05ee\u0007H\u0002\u0002\u05ee\u05ef\u0007G\u0002\u0002\u05ef", + "\u05f0\u0007V\u0002\u0002\u05f0\u05f1\u0007E\u0002\u0002\u05f1\u05f2", + "\u0007J\u0002\u0002\u05f2\u0088\u0003\u0002\u0002\u0002\u05f3\u05f4", + "\u0007H\u0002\u0002\u05f4\u05f5\u0007Q\u0002\u0002\u05f5\u05f6\u0007", + "T\u0002\u0002\u05f6\u008a\u0003\u0002\u0002\u0002\u05f7\u05f8\u0007", + "H\u0002\u0002\u05f8\u05f9\u0007Q\u0002\u0002\u05f9\u05fa\u0007T\u0002", + "\u0002\u05fa\u05fb\u0007G\u0002\u0002\u05fb\u05fc\u0007K\u0002\u0002", + "\u05fc\u05fd\u0007I\u0002\u0002\u05fd\u05fe\u0007P\u0002\u0002\u05fe", + "\u008c\u0003\u0002\u0002\u0002\u05ff\u0600\u0007H\u0002\u0002\u0600", + "\u0601\u0007T\u0002\u0002\u0601\u0602\u0007Q\u0002\u0002\u0602\u0603", + "\u0007O\u0002\u0002\u0603\u008e\u0003\u0002\u0002\u0002\u0604\u0605", + "\u0007I\u0002\u0002\u0605\u0606\u0007T\u0002\u0002\u0606\u0607\u0007", + "C\u0002\u0002\u0607\u0608\u0007P\u0002\u0002\u0608\u0609\u0007V\u0002", + "\u0002\u0609\u0090\u0003\u0002\u0002\u0002\u060a\u060b\u0007I\u0002", + "\u0002\u060b\u060c\u0007T\u0002\u0002\u060c\u060d\u0007Q\u0002\u0002", + "\u060d\u060e\u0007W\u0002\u0002\u060e\u060f\u0007R\u0002\u0002\u060f", + "\u0092\u0003\u0002\u0002\u0002\u0610\u0611\u0007J\u0002\u0002\u0611", + "\u0612\u0007C\u0002\u0002\u0612\u0613\u0007X\u0002\u0002\u0613\u0614", + "\u0007K\u0002\u0002\u0614\u0615\u0007P\u0002\u0002\u0615\u0616\u0007", + "I\u0002\u0002\u0616\u0094\u0003\u0002\u0002\u0002\u0617\u0618\u0007", + "K\u0002\u0002\u0618\u0619\u0007P\u0002\u0002\u0619\u0096\u0003\u0002", + "\u0002\u0002\u061a\u061b\u0007K\u0002\u0002\u061b\u061c\u0007P\u0002", + "\u0002\u061c\u061d\u0007K\u0002\u0002\u061d\u061e\u0007V\u0002\u0002", + "\u061e\u061f\u0007K\u0002\u0002\u061f\u0620\u0007C\u0002\u0002\u0620", + "\u0621\u0007N\u0002\u0002\u0621\u0622\u0007N\u0002\u0002\u0622\u0623", + "\u0007[\u0002\u0002\u0623\u0098\u0003\u0002\u0002\u0002\u0624\u0625", + "\u0007K\u0002\u0002\u0625\u0626\u0007P\u0002\u0002\u0626\u0627\u0007", + "V\u0002\u0002\u0627\u0628\u0007G\u0002\u0002\u0628\u0629\u0007T\u0002", + "\u0002\u0629\u062a\u0007U\u0002\u0002\u062a\u062b\u0007G\u0002\u0002", + "\u062b\u062c\u0007E\u0002\u0002\u062c\u062d\u0007V\u0002\u0002\u062d", + "\u009a\u0003\u0002\u0002\u0002\u062e\u062f\u0007K\u0002\u0002\u062f", + "\u0630\u0007P\u0002\u0002\u0630\u0631\u0007V\u0002\u0002\u0631\u0632", + "\u0007Q\u0002\u0002\u0632\u009c\u0003\u0002\u0002\u0002\u0633\u0634", + "\u0007N\u0002\u0002\u0634\u0635\u0007C\u0002\u0002\u0635\u0636\u0007", + "V\u0002\u0002\u0636\u0637\u0007G\u0002\u0002\u0637\u0638\u0007T\u0002", + "\u0002\u0638\u0639\u0007C\u0002\u0002\u0639\u063a\u0007N\u0002\u0002", + "\u063a\u009e\u0003\u0002\u0002\u0002\u063b\u063c\u0007N\u0002\u0002", + "\u063c\u063d\u0007G\u0002\u0002\u063d\u063e\u0007C\u0002\u0002\u063e", + "\u063f\u0007F\u0002\u0002\u063f\u0640\u0007K\u0002\u0002\u0640\u0641", + "\u0007P\u0002\u0002\u0641\u0642\u0007I\u0002\u0002\u0642\u00a0\u0003", + "\u0002\u0002\u0002\u0643\u0644\u0007N\u0002\u0002\u0644\u0645\u0007", + "K\u0002\u0002\u0645\u0646\u0007O\u0002\u0002\u0646\u0647\u0007K\u0002", + "\u0002\u0647\u0648\u0007V\u0002\u0002\u0648\u00a2\u0003\u0002\u0002", + "\u0002\u0649\u064a\u0007N\u0002\u0002\u064a\u064b\u0007Q\u0002\u0002", + "\u064b\u064c\u0007E\u0002\u0002\u064c\u064d\u0007C\u0002\u0002\u064d", + "\u064e\u0007N\u0002\u0002\u064e\u064f\u0007V\u0002\u0002\u064f\u0650", + "\u0007K\u0002\u0002\u0650\u0651\u0007O\u0002\u0002\u0651\u0652\u0007", + "G\u0002\u0002\u0652\u00a4\u0003\u0002\u0002\u0002\u0653\u0654\u0007", + "N\u0002\u0002\u0654\u0655\u0007Q\u0002\u0002\u0655\u0656\u0007E\u0002", + "\u0002\u0656\u0657\u0007C\u0002\u0002\u0657\u0658\u0007N\u0002\u0002", + "\u0658\u0659\u0007V\u0002\u0002\u0659\u065a\u0007K\u0002\u0002\u065a", + "\u065b\u0007O\u0002\u0002\u065b\u065c\u0007G\u0002\u0002\u065c\u065d", + "\u0007U\u0002\u0002\u065d\u065e\u0007V\u0002\u0002\u065e\u065f\u0007", + "C\u0002\u0002\u065f\u0660\u0007O\u0002\u0002\u0660\u0661\u0007R\u0002", + "\u0002\u0661\u00a6\u0003\u0002\u0002\u0002\u0662\u0663\u0007P\u0002", + "\u0002\u0663\u0664\u0007Q\u0002\u0002\u0664\u0665\u0007V\u0002\u0002", + "\u0665\u00a8\u0003\u0002\u0002\u0002\u0666\u0667\u0007P\u0002\u0002", + "\u0667\u0668\u0007W\u0002\u0002\u0668\u0669\u0007N\u0002\u0002\u0669", + "\u066a\u0007N\u0002\u0002\u066a\u00aa\u0003\u0002\u0002\u0002\u066b", + "\u066c\u0007Q\u0002\u0002\u066c\u066d\u0007H\u0002\u0002\u066d\u066e", + "\u0007H\u0002\u0002\u066e\u066f\u0007U\u0002\u0002\u066f\u0670\u0007", + "G\u0002\u0002\u0670\u0671\u0007V\u0002\u0002\u0671\u00ac\u0003\u0002", + "\u0002\u0002\u0672\u0673\u0007Q\u0002\u0002\u0673\u0674\u0007P\u0002", + "\u0002\u0674\u00ae\u0003\u0002\u0002\u0002\u0675\u0676\u0007Q\u0002", + "\u0002\u0676\u0677\u0007P\u0002\u0002\u0677\u0678\u0007N\u0002\u0002", + "\u0678\u0679\u0007[\u0002\u0002\u0679\u00b0\u0003\u0002\u0002\u0002", + "\u067a\u067b\u0007Q\u0002\u0002\u067b\u067c\u0007T\u0002\u0002\u067c", + "\u00b2\u0003\u0002\u0002\u0002\u067d\u067e\u0007Q\u0002\u0002\u067e", + "\u067f\u0007T\u0002\u0002\u067f\u0680\u0007F\u0002\u0002\u0680\u0681", + "\u0007G\u0002\u0002\u0681\u0682\u0007T\u0002\u0002\u0682\u00b4\u0003", + "\u0002\u0002\u0002\u0683\u0684\u0007R\u0002\u0002\u0684\u0685\u0007", + "N\u0002\u0002\u0685\u0686\u0007C\u0002\u0002\u0686\u0687\u0007E\u0002", + "\u0002\u0687\u0688\u0007K\u0002\u0002\u0688\u0689\u0007P\u0002\u0002", + "\u0689\u068a\u0007I\u0002\u0002\u068a\u00b6\u0003\u0002\u0002\u0002", + "\u068b\u068c\u0007R\u0002\u0002\u068c\u068d\u0007T\u0002\u0002\u068d", + "\u068e\u0007K\u0002\u0002\u068e\u068f\u0007O\u0002\u0002\u068f\u0690", + "\u0007C\u0002\u0002\u0690\u0691\u0007T\u0002\u0002\u0691\u0692\u0007", + "[\u0002\u0002\u0692\u00b8\u0003\u0002\u0002\u0002\u0693\u0694\u0007", + "T\u0002\u0002\u0694\u0695\u0007G\u0002\u0002\u0695\u0696\u0007H\u0002", + "\u0002\u0696\u0697\u0007G\u0002\u0002\u0697\u0698\u0007T\u0002\u0002", + "\u0698\u0699\u0007G\u0002\u0002\u0699\u069a\u0007P\u0002\u0002\u069a", + "\u069b\u0007E\u0002\u0002\u069b\u069c\u0007G\u0002\u0002\u069c\u069d", + "\u0007U\u0002\u0002\u069d\u00ba\u0003\u0002\u0002\u0002\u069e\u069f", + "\u0007T\u0002\u0002\u069f\u06a0\u0007G\u0002\u0002\u06a0\u06a1\u0007", + "V\u0002\u0002\u06a1\u06a2\u0007W\u0002\u0002\u06a2\u06a3\u0007T\u0002", + "\u0002\u06a3\u06a4\u0007P\u0002\u0002\u06a4\u06a5\u0007K\u0002\u0002", + "\u06a5\u06a6\u0007P\u0002\u0002\u06a6\u06a7\u0007I\u0002\u0002\u06a7", + "\u00bc\u0003\u0002\u0002\u0002\u06a8\u06a9\u0007U\u0002\u0002\u06a9", + "\u06aa\u0007G\u0002\u0002\u06aa\u06ab\u0007N\u0002\u0002\u06ab\u06ac", + "\u0007G\u0002\u0002\u06ac\u06ad\u0007E\u0002\u0002\u06ad\u06ae\u0007", + "V\u0002\u0002\u06ae\u00be\u0003\u0002\u0002\u0002\u06af\u06b0\u0007", + "U\u0002\u0002\u06b0\u06b1\u0007G\u0002\u0002\u06b1\u06b2\u0007U\u0002", + "\u0002\u06b2\u06b3\u0007U\u0002\u0002\u06b3\u06b4\u0007K\u0002\u0002", + "\u06b4\u06b5\u0007Q\u0002\u0002\u06b5\u06b6\u0007P\u0002\u0002\u06b6", + "\u06b7\u0007a\u0002\u0002\u06b7\u06b8\u0007W\u0002\u0002\u06b8\u06b9", + "\u0007U\u0002\u0002\u06b9\u06ba\u0007G\u0002\u0002\u06ba\u06bb\u0007", + "T\u0002\u0002\u06bb\u00c0\u0003\u0002\u0002\u0002\u06bc\u06bd\u0007", + "U\u0002\u0002\u06bd\u06be\u0007Q\u0002\u0002\u06be\u06bf\u0007O\u0002", + "\u0002\u06bf\u06c0\u0007G\u0002\u0002\u06c0\u00c2\u0003\u0002\u0002", + "\u0002\u06c1\u06c2\u0007U\u0002\u0002\u06c2\u06c3\u0007[\u0002\u0002", + "\u06c3\u06c4\u0007O\u0002\u0002\u06c4\u06c5\u0007O\u0002\u0002\u06c5", + "\u06c6\u0007G\u0002\u0002\u06c6\u06c7\u0007V\u0002\u0002\u06c7\u06c8", + "\u0007T\u0002\u0002\u06c8\u06c9\u0007K\u0002\u0002\u06c9\u06ca\u0007", + "E\u0002\u0002\u06ca\u00c4\u0003\u0002\u0002\u0002\u06cb\u06cc\u0007", + "V\u0002\u0002\u06cc\u06cd\u0007C\u0002\u0002\u06cd\u06ce\u0007D\u0002", + "\u0002\u06ce\u06cf\u0007N\u0002\u0002\u06cf\u06d0\u0007G\u0002\u0002", + "\u06d0\u00c6\u0003\u0002\u0002\u0002\u06d1\u06d2\u0007V\u0002\u0002", + "\u06d2\u06d3\u0007J\u0002\u0002\u06d3\u06d4\u0007G\u0002\u0002\u06d4", + "\u06d5\u0007P\u0002\u0002\u06d5\u00c8\u0003\u0002\u0002\u0002\u06d6", + "\u06d7\u0007V\u0002\u0002\u06d7\u06d8\u0007Q\u0002\u0002\u06d8\u00ca", + "\u0003\u0002\u0002\u0002\u06d9\u06da\u0007V\u0002\u0002\u06da\u06db", + "\u0007T\u0002\u0002\u06db\u06dc\u0007C\u0002\u0002\u06dc\u06dd\u0007", + "K\u0002\u0002\u06dd\u06de\u0007N\u0002\u0002\u06de\u06df\u0007K\u0002", + "\u0002\u06df\u06e0\u0007P\u0002\u0002\u06e0\u06e1\u0007I\u0002\u0002", + "\u06e1\u00cc\u0003\u0002\u0002\u0002\u06e2\u06e3\u0007V\u0002\u0002", + "\u06e3\u06e4\u0007T\u0002\u0002\u06e4\u06e5\u0007W\u0002\u0002\u06e5", + "\u06e6\u0007G\u0002\u0002\u06e6\u00ce\u0003\u0002\u0002\u0002\u06e7", + "\u06e8\u0007W\u0002\u0002\u06e8\u06e9\u0007P\u0002\u0002\u06e9\u06ea", + "\u0007K\u0002\u0002\u06ea\u06eb\u0007Q\u0002\u0002\u06eb\u06ec\u0007", + "P\u0002\u0002\u06ec\u00d0\u0003\u0002\u0002\u0002\u06ed\u06ee\u0007", + "W\u0002\u0002\u06ee\u06ef\u0007P\u0002\u0002\u06ef\u06f0\u0007K\u0002", + "\u0002\u06f0\u06f1\u0007S\u0002\u0002\u06f1\u06f2\u0007W\u0002\u0002", + "\u06f2\u06f3\u0007G\u0002\u0002\u06f3\u00d2\u0003\u0002\u0002\u0002", + "\u06f4\u06f5\u0007W\u0002\u0002\u06f5\u06f6\u0007U\u0002\u0002\u06f6", + "\u06f7\u0007G\u0002\u0002\u06f7\u06f8\u0007T\u0002\u0002\u06f8\u00d4", + "\u0003\u0002\u0002\u0002\u06f9\u06fa\u0007W\u0002\u0002\u06fa\u06fb", + "\u0007U\u0002\u0002\u06fb\u06fc\u0007K\u0002\u0002\u06fc\u06fd\u0007", + "P\u0002\u0002\u06fd\u06fe\u0007I\u0002\u0002\u06fe\u00d6\u0003\u0002", + "\u0002\u0002\u06ff\u0700\u0007X\u0002\u0002\u0700\u0701\u0007C\u0002", + "\u0002\u0701\u0702\u0007T\u0002\u0002\u0702\u0703\u0007K\u0002\u0002", + "\u0703\u0704\u0007C\u0002\u0002\u0704\u0705\u0007F\u0002\u0002\u0705", + "\u0706\u0007K\u0002\u0002\u0706\u0707\u0007E\u0002\u0002\u0707\u00d8", + "\u0003\u0002\u0002\u0002\u0708\u0709\u0007Y\u0002\u0002\u0709\u070a", + "\u0007J\u0002\u0002\u070a\u070b\u0007G\u0002\u0002\u070b\u070c\u0007", + "P\u0002\u0002\u070c\u00da\u0003\u0002\u0002\u0002\u070d\u070e\u0007", + "Y\u0002\u0002\u070e\u070f\u0007J\u0002\u0002\u070f\u0710\u0007G\u0002", + "\u0002\u0710\u0711\u0007T\u0002\u0002\u0711\u0712\u0007G\u0002\u0002", + "\u0712\u00dc\u0003\u0002\u0002\u0002\u0713\u0714\u0007Y\u0002\u0002", + "\u0714\u0715\u0007K\u0002\u0002\u0715\u0716\u0007P\u0002\u0002\u0716", + "\u0717\u0007F\u0002\u0002\u0717\u0718\u0007Q\u0002\u0002\u0718\u0719", + "\u0007Y\u0002\u0002\u0719\u00de\u0003\u0002\u0002\u0002\u071a\u071b", + "\u0007Y\u0002\u0002\u071b\u071c\u0007K\u0002\u0002\u071c\u071d\u0007", + "V\u0002\u0002\u071d\u071e\u0007J\u0002\u0002\u071e\u00e0\u0003\u0002", + "\u0002\u0002\u071f\u0720\u0007C\u0002\u0002\u0720\u0721\u0007W\u0002", + "\u0002\u0721\u0722\u0007V\u0002\u0002\u0722\u0723\u0007J\u0002\u0002", + "\u0723\u0724\u0007Q\u0002\u0002\u0724\u0725\u0007T\u0002\u0002\u0725", + "\u0726\u0007K\u0002\u0002\u0726\u0727\u0007\\\u0002\u0002\u0727\u0728", + "\u0007C\u0002\u0002\u0728\u0729\u0007V\u0002\u0002\u0729\u072a\u0007", + "K\u0002\u0002\u072a\u072b\u0007Q\u0002\u0002\u072b\u072c\u0007P\u0002", + "\u0002\u072c\u00e2\u0003\u0002\u0002\u0002\u072d\u072e\u0007D\u0002", + "\u0002\u072e\u072f\u0007K\u0002\u0002\u072f\u0730\u0007P\u0002\u0002", + "\u0730\u0731\u0007C\u0002\u0002\u0731\u0732\u0007T\u0002\u0002\u0732", + "\u0733\u0007[\u0002\u0002\u0733\u00e4\u0003\u0002\u0002\u0002\u0734", + "\u0735\u0007E\u0002\u0002\u0735\u0736\u0007Q\u0002\u0002\u0736\u0737", + "\u0007N\u0002\u0002\u0737\u0738\u0007N\u0002\u0002\u0738\u0739\u0007", + "C\u0002\u0002\u0739\u073a\u0007V\u0002\u0002\u073a\u073b\u0007K\u0002", + "\u0002\u073b\u073c\u0007Q\u0002\u0002\u073c\u073d\u0007P\u0002\u0002", + "\u073d\u00e6\u0003\u0002\u0002\u0002\u073e\u073f\u0007E\u0002\u0002", + "\u073f\u0740\u0007Q\u0002\u0002\u0740\u0741\u0007P\u0002\u0002\u0741", + "\u0742\u0007E\u0002\u0002\u0742\u0743\u0007W\u0002\u0002\u0743\u0744", + "\u0007T\u0002\u0002\u0744\u0745\u0007T\u0002\u0002\u0745\u0746\u0007", + "G\u0002\u0002\u0746\u0747\u0007P\u0002\u0002\u0747\u0748\u0007V\u0002", + "\u0002\u0748\u0749\u0007N\u0002\u0002\u0749\u074a\u0007[\u0002\u0002", + "\u074a\u00e8\u0003\u0002\u0002\u0002\u074b\u074c\u0007E\u0002\u0002", + "\u074c\u074d\u0007T\u0002\u0002\u074d\u074e\u0007Q\u0002\u0002\u074e", + "\u074f\u0007U\u0002\u0002\u074f\u0750\u0007U\u0002\u0002\u0750\u00ea", + "\u0003\u0002\u0002\u0002\u0751\u0752\u0007E\u0002\u0002\u0752\u0753", + "\u0007W\u0002\u0002\u0753\u0754\u0007T\u0002\u0002\u0754\u0755\u0007", + "T\u0002\u0002\u0755\u0756\u0007G\u0002\u0002\u0756\u0757\u0007P\u0002", + "\u0002\u0757\u0758\u0007V\u0002\u0002\u0758\u0759\u0007a\u0002\u0002", + "\u0759\u075a\u0007U\u0002\u0002\u075a\u075b\u0007E\u0002\u0002\u075b", + "\u075c\u0007J\u0002\u0002\u075c\u075d\u0007G\u0002\u0002\u075d\u075e", + "\u0007O\u0002\u0002\u075e\u075f\u0007C\u0002\u0002\u075f\u00ec\u0003", + "\u0002\u0002\u0002\u0760\u0761\u0007H\u0002\u0002\u0761\u0762\u0007", + "T\u0002\u0002\u0762\u0763\u0007G\u0002\u0002\u0763\u0764\u0007G\u0002", + "\u0002\u0764\u0765\u0007\\\u0002\u0002\u0765\u0766\u0007G\u0002\u0002", + "\u0766\u00ee\u0003\u0002\u0002\u0002\u0767\u0768\u0007H\u0002\u0002", + "\u0768\u0769\u0007W\u0002\u0002\u0769\u076a\u0007N\u0002\u0002\u076a", + "\u076b\u0007N\u0002\u0002\u076b\u00f0\u0003\u0002\u0002\u0002\u076c", + "\u076d\u0007K\u0002\u0002\u076d\u076e\u0007N\u0002\u0002\u076e\u076f", + "\u0007K\u0002\u0002\u076f\u0770\u0007M\u0002\u0002\u0770\u0771\u0007", + "G\u0002\u0002\u0771\u00f2\u0003\u0002\u0002\u0002\u0772\u0773\u0007", + "K\u0002\u0002\u0773\u0774\u0007P\u0002\u0002\u0774\u0775\u0007P\u0002", + "\u0002\u0775\u0776\u0007G\u0002\u0002\u0776\u0777\u0007T\u0002\u0002", + "\u0777\u00f4\u0003\u0002\u0002\u0002\u0778\u0779\u0007K\u0002\u0002", + "\u0779\u077a\u0007U\u0002\u0002\u077a\u00f6\u0003\u0002\u0002\u0002", + "\u077b\u077c\u0007K\u0002\u0002\u077c\u077d\u0007U\u0002\u0002\u077d", + "\u077e\u0007P\u0002\u0002\u077e\u077f\u0007W\u0002\u0002\u077f\u0780", + "\u0007N\u0002\u0002\u0780\u0781\u0007N\u0002\u0002\u0781\u00f8\u0003", + "\u0002\u0002\u0002\u0782\u0783\u0007L\u0002\u0002\u0783\u0784\u0007", + "Q\u0002\u0002\u0784\u0785\u0007K\u0002\u0002\u0785\u0786\u0007P\u0002", + "\u0002\u0786\u00fa\u0003\u0002\u0002\u0002\u0787\u0788\u0007N\u0002", + "\u0002\u0788\u0789\u0007G\u0002\u0002\u0789\u078a\u0007H\u0002\u0002", + "\u078a\u078b\u0007V\u0002\u0002\u078b\u00fc\u0003\u0002\u0002\u0002", + "\u078c\u078d\u0007N\u0002\u0002\u078d\u078e\u0007K\u0002\u0002\u078e", + "\u078f\u0007M\u0002\u0002\u078f\u0790\u0007G\u0002\u0002\u0790\u00fe", + "\u0003\u0002\u0002\u0002\u0791\u0792\u0007P\u0002\u0002\u0792\u0793", + "\u0007C\u0002\u0002\u0793\u0794\u0007V\u0002\u0002\u0794\u0795\u0007", + "W\u0002\u0002\u0795\u0796\u0007T\u0002\u0002\u0796\u0797\u0007C\u0002", + "\u0002\u0797\u0798\u0007N\u0002\u0002\u0798\u0100\u0003\u0002\u0002", + "\u0002\u0799\u079a\u0007P\u0002\u0002\u079a\u079b\u0007Q\u0002\u0002", + "\u079b\u079c\u0007V\u0002\u0002\u079c\u079d\u0007P\u0002\u0002\u079d", + "\u079e\u0007W\u0002\u0002\u079e\u079f\u0007N\u0002\u0002\u079f\u07a0", + "\u0007N\u0002\u0002\u07a0\u0102\u0003\u0002\u0002\u0002\u07a1\u07a2", + "\u0007Q\u0002\u0002\u07a2\u07a3\u0007W\u0002\u0002\u07a3\u07a4\u0007", + "V\u0002\u0002\u07a4\u07a5\u0007G\u0002\u0002\u07a5\u07a6\u0007T\u0002", + "\u0002\u07a6\u0104\u0003\u0002\u0002\u0002\u07a7\u07a8\u0007Q\u0002", + "\u0002\u07a8\u07a9\u0007X\u0002\u0002\u07a9\u07aa\u0007G\u0002\u0002", + "\u07aa\u07ab\u0007T\u0002\u0002\u07ab\u0106\u0003\u0002\u0002\u0002", + "\u07ac\u07ad\u0007Q\u0002\u0002\u07ad\u07ae\u0007X\u0002\u0002\u07ae", + "\u07af\u0007G\u0002\u0002\u07af\u07b0\u0007T\u0002\u0002\u07b0\u07b1", + "\u0007N\u0002\u0002\u07b1\u07b2\u0007C\u0002\u0002\u07b2\u07b3\u0007", + "R\u0002\u0002\u07b3\u07b4\u0007U\u0002\u0002\u07b4\u0108\u0003\u0002", + "\u0002\u0002\u07b5\u07b6\u0007T\u0002\u0002\u07b6\u07b7\u0007K\u0002", + "\u0002\u07b7\u07b8\u0007I\u0002\u0002\u07b8\u07b9\u0007J\u0002\u0002", + "\u07b9\u07ba\u0007V\u0002\u0002\u07ba\u010a\u0003\u0002\u0002\u0002", + "\u07bb\u07bc\u0007U\u0002\u0002\u07bc\u07bd\u0007K\u0002\u0002\u07bd", + "\u07be\u0007O\u0002\u0002\u07be\u07bf\u0007K\u0002\u0002\u07bf\u07c0", + "\u0007N\u0002\u0002\u07c0\u07c1\u0007C\u0002\u0002\u07c1\u07c2\u0007", + "T\u0002\u0002\u07c2\u010c\u0003\u0002\u0002\u0002\u07c3\u07c4\u0007", + "X\u0002\u0002\u07c4\u07c5\u0007G\u0002\u0002\u07c5\u07c6\u0007T\u0002", + "\u0002\u07c6\u07c7\u0007D\u0002\u0002\u07c7\u07c8\u0007Q\u0002\u0002", + "\u07c8\u07c9\u0007U\u0002\u0002\u07c9\u07ca\u0007G\u0002\u0002\u07ca", + "\u010e\u0003\u0002\u0002\u0002\u07cb\u07cc\u0007C\u0002\u0002\u07cc", + "\u07cd\u0007D\u0002\u0002\u07cd\u07ce\u0007Q\u0002\u0002\u07ce\u07cf", + "\u0007T\u0002\u0002\u07cf\u07d0\u0007V\u0002\u0002\u07d0\u0110\u0003", + "\u0002\u0002\u0002\u07d1\u07d2\u0007C\u0002\u0002\u07d2\u07d3\u0007", + "D\u0002\u0002\u07d3\u07d4\u0007U\u0002\u0002\u07d4\u07d5\u0007Q\u0002", + "\u0002\u07d5\u07d6\u0007N\u0002\u0002\u07d6\u07d7\u0007W\u0002\u0002", + "\u07d7\u07d8\u0007V\u0002\u0002\u07d8\u07d9\u0007G\u0002\u0002\u07d9", + "\u0112\u0003\u0002\u0002\u0002\u07da\u07db\u0007C\u0002\u0002\u07db", + "\u07dc\u0007E\u0002\u0002\u07dc\u07dd\u0007E\u0002\u0002\u07dd\u07de", + "\u0007G\u0002\u0002\u07de\u07df\u0007U\u0002\u0002\u07df\u07e0\u0007", + "U\u0002\u0002\u07e0\u0114\u0003\u0002\u0002\u0002\u07e1\u07e2\u0007", + "C\u0002\u0002\u07e2\u07e3\u0007E\u0002\u0002\u07e3\u07e4\u0007V\u0002", + "\u0002\u07e4\u07e5\u0007K\u0002\u0002\u07e5\u07e6\u0007Q\u0002\u0002", + "\u07e6\u07e7\u0007P\u0002\u0002\u07e7\u0116\u0003\u0002\u0002\u0002", + "\u07e8\u07e9\u0007C\u0002\u0002\u07e9\u07ea\u0007F\u0002\u0002\u07ea", + "\u07eb\u0007F\u0002\u0002\u07eb\u0118\u0003\u0002\u0002\u0002\u07ec", + "\u07ed\u0007C\u0002\u0002\u07ed\u07ee\u0007F\u0002\u0002\u07ee\u07ef", + "\u0007O\u0002\u0002\u07ef\u07f0\u0007K\u0002\u0002\u07f0\u07f1\u0007", + "P\u0002\u0002\u07f1\u011a\u0003\u0002\u0002\u0002\u07f2\u07f3\u0007", + "C\u0002\u0002\u07f3\u07f4\u0007H\u0002\u0002\u07f4\u07f5\u0007V\u0002", + "\u0002\u07f5\u07f6\u0007G\u0002\u0002\u07f6\u07f7\u0007T\u0002\u0002", + "\u07f7\u011c\u0003\u0002\u0002\u0002\u07f8\u07f9\u0007C\u0002\u0002", + "\u07f9\u07fa\u0007I\u0002\u0002\u07fa\u07fb\u0007I\u0002\u0002\u07fb", + "\u07fc\u0007T\u0002\u0002\u07fc\u07fd\u0007G\u0002\u0002\u07fd\u07fe", + "\u0007I\u0002\u0002\u07fe\u07ff\u0007C\u0002\u0002\u07ff\u0800\u0007", + "V\u0002\u0002\u0800\u0801\u0007G\u0002\u0002\u0801\u011e\u0003\u0002", + "\u0002\u0002\u0802\u0803\u0007C\u0002\u0002\u0803\u0804\u0007N\u0002", + "\u0002\u0804\u0805\u0007U\u0002\u0002\u0805\u0806\u0007Q\u0002\u0002", + "\u0806\u0120\u0003\u0002\u0002\u0002\u0807\u0808\u0007C\u0002\u0002", + "\u0808\u0809\u0007N\u0002\u0002\u0809\u080a\u0007V\u0002\u0002\u080a", + "\u080b\u0007G\u0002\u0002\u080b\u080c\u0007T\u0002\u0002\u080c\u0122", + "\u0003\u0002\u0002\u0002\u080d\u080e\u0007C\u0002\u0002\u080e\u080f", + "\u0007N\u0002\u0002\u080f\u0810\u0007Y\u0002\u0002\u0810\u0811\u0007", + "C\u0002\u0002\u0811\u0812\u0007[\u0002\u0002\u0812\u0813\u0007U\u0002", + "\u0002\u0813\u0124\u0003\u0002\u0002\u0002\u0814\u0815\u0007C\u0002", + "\u0002\u0815\u0816\u0007U\u0002\u0002\u0816\u0817\u0007U\u0002\u0002", + "\u0817\u0818\u0007G\u0002\u0002\u0818\u0819\u0007T\u0002\u0002\u0819", + "\u081a\u0007V\u0002\u0002\u081a\u081b\u0007K\u0002\u0002\u081b\u081c", + "\u0007Q\u0002\u0002\u081c\u081d\u0007P\u0002\u0002\u081d\u0126\u0003", + "\u0002\u0002\u0002\u081e\u081f\u0007C\u0002\u0002\u081f\u0820\u0007", + "U\u0002\u0002\u0820\u0821\u0007U\u0002\u0002\u0821\u0822\u0007K\u0002", + "\u0002\u0822\u0823\u0007I\u0002\u0002\u0823\u0824\u0007P\u0002\u0002", + "\u0824\u0825\u0007O\u0002\u0002\u0825\u0826\u0007G\u0002\u0002\u0826", + "\u0827\u0007P\u0002\u0002\u0827\u0828\u0007V\u0002\u0002\u0828\u0128", + "\u0003\u0002\u0002\u0002\u0829\u082a\u0007C\u0002\u0002\u082a\u082b", + "\u0007V\u0002\u0002\u082b\u012a\u0003\u0002\u0002\u0002\u082c\u082d", + "\u0007C\u0002\u0002\u082d\u082e\u0007V\u0002\u0002\u082e\u082f\u0007", + "V\u0002\u0002\u082f\u0830\u0007T\u0002\u0002\u0830\u0831\u0007K\u0002", + "\u0002\u0831\u0832\u0007D\u0002\u0002\u0832\u0833\u0007W\u0002\u0002", + "\u0833\u0834\u0007V\u0002\u0002\u0834\u0835\u0007G\u0002\u0002\u0835", + "\u012c\u0003\u0002\u0002\u0002\u0836\u0837\u0007D\u0002\u0002\u0837", + "\u0838\u0007C\u0002\u0002\u0838\u0839\u0007E\u0002\u0002\u0839\u083a", + "\u0007M\u0002\u0002\u083a\u083b\u0007Y\u0002\u0002\u083b\u083c\u0007", + "C\u0002\u0002\u083c\u083d\u0007T\u0002\u0002\u083d\u083e\u0007F\u0002", + "\u0002\u083e\u012e\u0003\u0002\u0002\u0002\u083f\u0840\u0007D\u0002", + "\u0002\u0840\u0841\u0007G\u0002\u0002\u0841\u0842\u0007H\u0002\u0002", + "\u0842\u0843\u0007Q\u0002\u0002\u0843\u0844\u0007T\u0002\u0002\u0844", + "\u0845\u0007G\u0002\u0002\u0845\u0130\u0003\u0002\u0002\u0002\u0846", + "\u0847\u0007D\u0002\u0002\u0847\u0848\u0007G\u0002\u0002\u0848\u0849", + "\u0007I\u0002\u0002\u0849\u084a\u0007K\u0002\u0002\u084a\u084b\u0007", + "P\u0002\u0002\u084b\u0132\u0003\u0002\u0002\u0002\u084c\u084d\u0007", + "D\u0002\u0002\u084d\u084e\u0007[\u0002\u0002\u084e\u0134\u0003\u0002", + "\u0002\u0002\u084f\u0850\u0007E\u0002\u0002\u0850\u0851\u0007C\u0002", + "\u0002\u0851\u0852\u0007E\u0002\u0002\u0852\u0853\u0007J\u0002\u0002", + "\u0853\u0854\u0007G\u0002\u0002\u0854\u0136\u0003\u0002\u0002\u0002", + "\u0855\u0856\u0007E\u0002\u0002\u0856\u0857\u0007C\u0002\u0002\u0857", + "\u0858\u0007N\u0002\u0002\u0858\u0859\u0007N\u0002\u0002\u0859\u085a", + "\u0007G\u0002\u0002\u085a\u085b\u0007F\u0002\u0002\u085b\u0138\u0003", + "\u0002\u0002\u0002\u085c\u085d\u0007E\u0002\u0002\u085d\u085e\u0007", + "C\u0002\u0002\u085e\u085f\u0007U\u0002\u0002\u085f\u0860\u0007E\u0002", + "\u0002\u0860\u0861\u0007C\u0002\u0002\u0861\u0862\u0007F\u0002\u0002", + "\u0862\u0863\u0007G\u0002\u0002\u0863\u013a\u0003\u0002\u0002\u0002", + "\u0864\u0865\u0007E\u0002\u0002\u0865\u0866\u0007C\u0002\u0002\u0866", + "\u0867\u0007U\u0002\u0002\u0867\u0868\u0007E\u0002\u0002\u0868\u0869", + "\u0007C\u0002\u0002\u0869\u086a\u0007F\u0002\u0002\u086a\u086b\u0007", + "G\u0002\u0002\u086b\u086c\u0007F\u0002\u0002\u086c\u013c\u0003\u0002", + "\u0002\u0002\u086d\u086e\u0007E\u0002\u0002\u086e\u086f\u0007C\u0002", + "\u0002\u086f\u0870\u0007V\u0002\u0002\u0870\u0871\u0007C\u0002\u0002", + "\u0871\u0872\u0007N\u0002\u0002\u0872\u0873\u0007Q\u0002\u0002\u0873", + "\u0874\u0007I\u0002\u0002\u0874\u013e\u0003\u0002\u0002\u0002\u0875", + "\u0876\u0007E\u0002\u0002\u0876\u0877\u0007J\u0002\u0002\u0877\u0878", + "\u0007C\u0002\u0002\u0878\u0879\u0007K\u0002\u0002\u0879\u087a\u0007", + "P\u0002\u0002\u087a\u0140\u0003\u0002\u0002\u0002\u087b\u087c\u0007", + "E\u0002\u0002\u087c\u087d\u0007J\u0002\u0002\u087d\u087e\u0007C\u0002", + "\u0002\u087e\u087f\u0007T\u0002\u0002\u087f\u0880\u0007C\u0002\u0002", + "\u0880\u0881\u0007E\u0002\u0002\u0881\u0882\u0007V\u0002\u0002\u0882", + "\u0883\u0007G\u0002\u0002\u0883\u0884\u0007T\u0002\u0002\u0884\u0885", + "\u0007K\u0002\u0002\u0885\u0886\u0007U\u0002\u0002\u0886\u0887\u0007", + "V\u0002\u0002\u0887\u0888\u0007K\u0002\u0002\u0888\u0889\u0007E\u0002", + "\u0002\u0889\u088a\u0007U\u0002\u0002\u088a\u0142\u0003\u0002\u0002", + "\u0002\u088b\u088c\u0007E\u0002\u0002\u088c\u088d\u0007J\u0002\u0002", + "\u088d\u088e\u0007G\u0002\u0002\u088e\u088f\u0007E\u0002\u0002\u088f", + "\u0890\u0007M\u0002\u0002\u0890\u0891\u0007R\u0002\u0002\u0891\u0892", + "\u0007Q\u0002\u0002\u0892\u0893\u0007K\u0002\u0002\u0893\u0894\u0007", + "P\u0002\u0002\u0894\u0895\u0007V\u0002\u0002\u0895\u0144\u0003\u0002", + "\u0002\u0002\u0896\u0897\u0007E\u0002\u0002\u0897\u0898\u0007N\u0002", + "\u0002\u0898\u0899\u0007C\u0002\u0002\u0899\u089a\u0007U\u0002\u0002", + "\u089a\u089b\u0007U\u0002\u0002\u089b\u0146\u0003\u0002\u0002\u0002", + "\u089c\u089d\u0007E\u0002\u0002\u089d\u089e\u0007N\u0002\u0002\u089e", + "\u089f\u0007Q\u0002\u0002\u089f\u08a0\u0007U\u0002\u0002\u08a0\u08a1", + "\u0007G\u0002\u0002\u08a1\u0148\u0003\u0002\u0002\u0002\u08a2\u08a3", + "\u0007E\u0002\u0002\u08a3\u08a4\u0007N\u0002\u0002\u08a4\u08a5\u0007", + "W\u0002\u0002\u08a5\u08a6\u0007U\u0002\u0002\u08a6\u08a7\u0007V\u0002", + "\u0002\u08a7\u08a8\u0007G\u0002\u0002\u08a8\u08a9\u0007T\u0002\u0002", + "\u08a9\u014a\u0003\u0002\u0002\u0002\u08aa\u08ab\u0007E\u0002\u0002", + "\u08ab\u08ac\u0007Q\u0002\u0002\u08ac\u08ad\u0007O\u0002\u0002\u08ad", + "\u08ae\u0007O\u0002\u0002\u08ae\u08af\u0007G\u0002\u0002\u08af\u08b0", + "\u0007P\u0002\u0002\u08b0\u08b1\u0007V\u0002\u0002\u08b1\u014c\u0003", + "\u0002\u0002\u0002\u08b2\u08b3\u0007E\u0002\u0002\u08b3\u08b4\u0007", + "Q\u0002\u0002\u08b4\u08b5\u0007O\u0002\u0002\u08b5\u08b6\u0007O\u0002", + "\u0002\u08b6\u08b7\u0007G\u0002\u0002\u08b7\u08b8\u0007P\u0002\u0002", + "\u08b8\u08b9\u0007V\u0002\u0002\u08b9\u08ba\u0007U\u0002\u0002\u08ba", + "\u014e\u0003\u0002\u0002\u0002\u08bb\u08bc\u0007E\u0002\u0002\u08bc", + "\u08bd\u0007Q\u0002\u0002\u08bd\u08be\u0007O\u0002\u0002\u08be\u08bf", + "\u0007O\u0002\u0002\u08bf\u08c0\u0007K\u0002\u0002\u08c0\u08c1\u0007", + "V\u0002\u0002\u08c1\u0150\u0003\u0002\u0002\u0002\u08c2\u08c3\u0007", + "E\u0002\u0002\u08c3\u08c4\u0007Q\u0002\u0002\u08c4\u08c5\u0007O\u0002", + "\u0002\u08c5\u08c6\u0007O\u0002\u0002\u08c6\u08c7\u0007K\u0002\u0002", + "\u08c7\u08c8\u0007V\u0002\u0002\u08c8\u08c9\u0007V\u0002\u0002\u08c9", + "\u08ca\u0007G\u0002\u0002\u08ca\u08cb\u0007F\u0002\u0002\u08cb\u0152", + "\u0003\u0002\u0002\u0002\u08cc\u08cd\u0007E\u0002\u0002\u08cd\u08ce", + "\u0007Q\u0002\u0002\u08ce\u08cf\u0007P\u0002\u0002\u08cf\u08d0\u0007", + "H\u0002\u0002\u08d0\u08d1\u0007K\u0002\u0002\u08d1\u08d2\u0007I\u0002", + "\u0002\u08d2\u08d3\u0007W\u0002\u0002\u08d3\u08d4\u0007T\u0002\u0002", + "\u08d4\u08d5\u0007C\u0002\u0002\u08d5\u08d6\u0007V\u0002\u0002\u08d6", + "\u08d7\u0007K\u0002\u0002\u08d7\u08d8\u0007Q\u0002\u0002\u08d8\u08d9", + "\u0007P\u0002\u0002\u08d9\u0154\u0003\u0002\u0002\u0002\u08da\u08db", + "\u0007E\u0002\u0002\u08db\u08dc\u0007Q\u0002\u0002\u08dc\u08dd\u0007", + "P\u0002\u0002\u08dd\u08de\u0007P\u0002\u0002\u08de\u08df\u0007G\u0002", + "\u0002\u08df\u08e0\u0007E\u0002\u0002\u08e0\u08e1\u0007V\u0002\u0002", + "\u08e1\u08e2\u0007K\u0002\u0002\u08e2\u08e3\u0007Q\u0002\u0002\u08e3", + "\u08e4\u0007P\u0002\u0002\u08e4\u0156\u0003\u0002\u0002\u0002\u08e5", + "\u08e6\u0007E\u0002\u0002\u08e6\u08e7\u0007Q\u0002\u0002\u08e7\u08e8", + "\u0007P\u0002\u0002\u08e8\u08e9\u0007U\u0002\u0002\u08e9\u08ea\u0007", + "V\u0002\u0002\u08ea\u08eb\u0007T\u0002\u0002\u08eb\u08ec\u0007C\u0002", + "\u0002\u08ec\u08ed\u0007K\u0002\u0002\u08ed\u08ee\u0007P\u0002\u0002", + "\u08ee\u08ef\u0007V\u0002\u0002\u08ef\u08f0\u0007U\u0002\u0002\u08f0", + "\u0158\u0003\u0002\u0002\u0002\u08f1\u08f2\u0007E\u0002\u0002\u08f2", + "\u08f3\u0007Q\u0002\u0002\u08f3\u08f4\u0007P\u0002\u0002\u08f4\u08f5", + "\u0007V\u0002\u0002\u08f5\u08f6\u0007G\u0002\u0002\u08f6\u08f7\u0007", + "P\u0002\u0002\u08f7\u08f8\u0007V\u0002\u0002\u08f8\u015a\u0003\u0002", + "\u0002\u0002\u08f9\u08fa\u0007E\u0002\u0002\u08fa\u08fb\u0007Q\u0002", + "\u0002\u08fb\u08fc\u0007P\u0002\u0002\u08fc\u08fd\u0007V\u0002\u0002", + "\u08fd\u08fe\u0007K\u0002\u0002\u08fe\u08ff\u0007P\u0002\u0002\u08ff", + "\u0900\u0007W\u0002\u0002\u0900\u0901\u0007G\u0002\u0002\u0901\u015c", + "\u0003\u0002\u0002\u0002\u0902\u0903\u0007E\u0002\u0002\u0903\u0904", + "\u0007Q\u0002\u0002\u0904\u0905\u0007P\u0002\u0002\u0905\u0906\u0007", + "X\u0002\u0002\u0906\u0907\u0007G\u0002\u0002\u0907\u0908\u0007T\u0002", + "\u0002\u0908\u0909\u0007U\u0002\u0002\u0909\u090a\u0007K\u0002\u0002", + "\u090a\u090b\u0007Q\u0002\u0002\u090b\u090c\u0007P\u0002\u0002\u090c", + "\u015e\u0003\u0002\u0002\u0002\u090d\u090e\u0007E\u0002\u0002\u090e", + "\u090f\u0007Q\u0002\u0002\u090f\u0910\u0007R\u0002\u0002\u0910\u0911", + "\u0007[\u0002\u0002\u0911\u0160\u0003\u0002\u0002\u0002\u0912\u0913", + "\u0007E\u0002\u0002\u0913\u0914\u0007Q\u0002\u0002\u0914\u0915\u0007", + "U\u0002\u0002\u0915\u0916\u0007V\u0002\u0002\u0916\u0162\u0003\u0002", + "\u0002\u0002\u0917\u0918\u0007E\u0002\u0002\u0918\u0919\u0007U\u0002", + "\u0002\u0919\u091a\u0007X\u0002\u0002\u091a\u0164\u0003\u0002\u0002", + "\u0002\u091b\u091c\u0007E\u0002\u0002\u091c\u091d\u0007W\u0002\u0002", + "\u091d\u091e\u0007T\u0002\u0002\u091e\u091f\u0007U\u0002\u0002\u091f", + "\u0920\u0007Q\u0002\u0002\u0920\u0921\u0007T\u0002\u0002\u0921\u0166", + "\u0003\u0002\u0002\u0002\u0922\u0923\u0007E\u0002\u0002\u0923\u0924", + "\u0007[\u0002\u0002\u0924\u0925\u0007E\u0002\u0002\u0925\u0926\u0007", + "N\u0002\u0002\u0926\u0927\u0007G\u0002\u0002\u0927\u0168\u0003\u0002", + "\u0002\u0002\u0928\u0929\u0007F\u0002\u0002\u0929\u092a\u0007C\u0002", + "\u0002\u092a\u092b\u0007V\u0002\u0002\u092b\u092c\u0007C\u0002\u0002", + "\u092c\u016a\u0003\u0002\u0002\u0002\u092d\u092e\u0007F\u0002\u0002", + "\u092e\u092f\u0007C\u0002\u0002\u092f\u0930\u0007V\u0002\u0002\u0930", + "\u0931\u0007C\u0002\u0002\u0931\u0932\u0007D\u0002\u0002\u0932\u0933", + "\u0007C\u0002\u0002\u0933\u0934\u0007U\u0002\u0002\u0934\u0935\u0007", + "G\u0002\u0002\u0935\u016c\u0003\u0002\u0002\u0002\u0936\u0937\u0007", + "F\u0002\u0002\u0937\u0938\u0007C\u0002\u0002\u0938\u0939\u0007[\u0002", + "\u0002\u0939\u016e\u0003\u0002\u0002\u0002\u093a\u093b\u0007F\u0002", + "\u0002\u093b\u093c\u0007G\u0002\u0002\u093c\u093d\u0007C\u0002\u0002", + "\u093d\u093e\u0007N\u0002\u0002\u093e\u093f\u0007N\u0002\u0002\u093f", + "\u0940\u0007Q\u0002\u0002\u0940\u0941\u0007E\u0002\u0002\u0941\u0942", + "\u0007C\u0002\u0002\u0942\u0943\u0007V\u0002\u0002\u0943\u0944\u0007", + "G\u0002\u0002\u0944\u0170\u0003\u0002\u0002\u0002\u0945\u0946\u0007", + "F\u0002\u0002\u0946\u0947\u0007G\u0002\u0002\u0947\u0948\u0007E\u0002", + "\u0002\u0948\u0949\u0007N\u0002\u0002\u0949\u094a\u0007C\u0002\u0002", + "\u094a\u094b\u0007T\u0002\u0002\u094b\u094c\u0007G\u0002\u0002\u094c", + "\u0172\u0003\u0002\u0002\u0002\u094d\u094e\u0007F\u0002\u0002\u094e", + "\u094f\u0007G\u0002\u0002\u094f\u0950\u0007H\u0002\u0002\u0950\u0951", + "\u0007C\u0002\u0002\u0951\u0952\u0007W\u0002\u0002\u0952\u0953\u0007", + "N\u0002\u0002\u0953\u0954\u0007V\u0002\u0002\u0954\u0955\u0007U\u0002", + "\u0002\u0955\u0174\u0003\u0002\u0002\u0002\u0956\u0957\u0007F\u0002", + "\u0002\u0957\u0958\u0007G\u0002\u0002\u0958\u0959\u0007H\u0002\u0002", + "\u0959\u095a\u0007G\u0002\u0002\u095a\u095b\u0007T\u0002\u0002\u095b", + "\u095c\u0007T\u0002\u0002\u095c\u095d\u0007G\u0002\u0002\u095d\u095e", + "\u0007F\u0002\u0002\u095e\u0176\u0003\u0002\u0002\u0002\u095f\u0960", + "\u0007F\u0002\u0002\u0960\u0961\u0007G\u0002\u0002\u0961\u0962\u0007", + "H\u0002\u0002\u0962\u0963\u0007K\u0002\u0002\u0963\u0964\u0007P\u0002", + "\u0002\u0964\u0965\u0007G\u0002\u0002\u0965\u0966\u0007T\u0002\u0002", + "\u0966\u0178\u0003\u0002\u0002\u0002\u0967\u0968\u0007F\u0002\u0002", + "\u0968\u0969\u0007G\u0002\u0002\u0969\u096a\u0007N\u0002\u0002\u096a", + "\u096b\u0007G\u0002\u0002\u096b\u096c\u0007V\u0002\u0002\u096c\u096d", + "\u0007G\u0002\u0002\u096d\u017a\u0003\u0002\u0002\u0002\u096e\u096f", + "\u0007F\u0002\u0002\u096f\u0970\u0007G\u0002\u0002\u0970\u0971\u0007", + "N\u0002\u0002\u0971\u0972\u0007K\u0002\u0002\u0972\u0973\u0007O\u0002", + "\u0002\u0973\u0974\u0007K\u0002\u0002\u0974\u0975\u0007V\u0002\u0002", + "\u0975\u0976\u0007G\u0002\u0002\u0976\u0977\u0007T\u0002\u0002\u0977", + "\u017c\u0003\u0002\u0002\u0002\u0978\u0979\u0007F\u0002\u0002\u0979", + "\u097a\u0007G\u0002\u0002\u097a\u097b\u0007N\u0002\u0002\u097b\u097c", + "\u0007K\u0002\u0002\u097c\u097d\u0007O\u0002\u0002\u097d\u097e\u0007", + "K\u0002\u0002\u097e\u097f\u0007V\u0002\u0002\u097f\u0980\u0007G\u0002", + "\u0002\u0980\u0981\u0007T\u0002\u0002\u0981\u0982\u0007U\u0002\u0002", + "\u0982\u017e\u0003\u0002\u0002\u0002\u0983\u0984\u0007F\u0002\u0002", + "\u0984\u0985\u0007K\u0002\u0002\u0985\u0986\u0007E\u0002\u0002\u0986", + "\u0987\u0007V\u0002\u0002\u0987\u0988\u0007K\u0002\u0002\u0988\u0989", + "\u0007Q\u0002\u0002\u0989\u098a\u0007P\u0002\u0002\u098a\u098b\u0007", + "C\u0002\u0002\u098b\u098c\u0007T\u0002\u0002\u098c\u098d\u0007[\u0002", + "\u0002\u098d\u0180\u0003\u0002\u0002\u0002\u098e\u098f\u0007F\u0002", + "\u0002\u098f\u0990\u0007K\u0002\u0002\u0990\u0991\u0007U\u0002\u0002", + "\u0991\u0992\u0007C\u0002\u0002\u0992\u0993\u0007D\u0002\u0002\u0993", + "\u0994\u0007N\u0002\u0002\u0994\u0995\u0007G\u0002\u0002\u0995\u0182", + "\u0003\u0002\u0002\u0002\u0996\u0997\u0007F\u0002\u0002\u0997\u0998", + "\u0007K\u0002\u0002\u0998\u0999\u0007U\u0002\u0002\u0999\u099a\u0007", + "E\u0002\u0002\u099a\u099b\u0007C\u0002\u0002\u099b\u099c\u0007T\u0002", + "\u0002\u099c\u099d\u0007F\u0002\u0002\u099d\u0184\u0003\u0002\u0002", + "\u0002\u099e\u099f\u0007F\u0002\u0002\u099f\u09a0\u0007Q\u0002\u0002", + "\u09a0\u09a1\u0007E\u0002\u0002\u09a1\u09a2\u0007W\u0002\u0002\u09a2", + "\u09a3\u0007O\u0002\u0002\u09a3\u09a4\u0007G\u0002\u0002\u09a4\u09a5", + "\u0007P\u0002\u0002\u09a5\u09a6\u0007V\u0002\u0002\u09a6\u0186\u0003", + "\u0002\u0002\u0002\u09a7\u09a8\u0007F\u0002\u0002\u09a8\u09a9\u0007", + "Q\u0002\u0002\u09a9\u09aa\u0007O\u0002\u0002\u09aa\u09ab\u0007C\u0002", + "\u0002\u09ab\u09ac\u0007K\u0002\u0002\u09ac\u09ad\u0007P\u0002\u0002", + "\u09ad\u0188\u0003\u0002\u0002\u0002\u09ae\u09af\u0007F\u0002\u0002", + "\u09af\u09b0\u0007Q\u0002\u0002\u09b0\u09b1\u0007W\u0002\u0002\u09b1", + "\u09b2\u0007D\u0002\u0002\u09b2\u09b3\u0007N\u0002\u0002\u09b3\u09b4", + "\u0007G\u0002\u0002\u09b4\u018a\u0003\u0002\u0002\u0002\u09b5\u09b6", + "\u0007F\u0002\u0002\u09b6\u09b7\u0007T\u0002\u0002\u09b7\u09b8\u0007", + "Q\u0002\u0002\u09b8\u09b9\u0007R\u0002\u0002\u09b9\u018c\u0003\u0002", + "\u0002\u0002\u09ba\u09bb\u0007G\u0002\u0002\u09bb\u09bc\u0007C\u0002", + "\u0002\u09bc\u09bd\u0007E\u0002\u0002\u09bd\u09be\u0007J\u0002\u0002", + "\u09be\u018e\u0003\u0002\u0002\u0002\u09bf\u09c0\u0007G\u0002\u0002", + "\u09c0\u09c1\u0007P\u0002\u0002\u09c1\u09c2\u0007C\u0002\u0002\u09c2", + "\u09c3\u0007D\u0002\u0002\u09c3\u09c4\u0007N\u0002\u0002\u09c4\u09c5", + "\u0007G\u0002\u0002\u09c5\u0190\u0003\u0002\u0002\u0002\u09c6\u09c7", + "\u0007G\u0002\u0002\u09c7\u09c8\u0007P\u0002\u0002\u09c8\u09c9\u0007", + "E\u0002\u0002\u09c9\u09ca\u0007Q\u0002\u0002\u09ca\u09cb\u0007F\u0002", + "\u0002\u09cb\u09cc\u0007K\u0002\u0002\u09cc\u09cd\u0007P\u0002\u0002", + "\u09cd\u09ce\u0007I\u0002\u0002\u09ce\u0192\u0003\u0002\u0002\u0002", + "\u09cf\u09d0\u0007G\u0002\u0002\u09d0\u09d1\u0007P\u0002\u0002\u09d1", + "\u09d2\u0007E\u0002\u0002\u09d2\u09d3\u0007T\u0002\u0002\u09d3\u09d4", + "\u0007[\u0002\u0002\u09d4\u09d5\u0007R\u0002\u0002\u09d5\u09d6\u0007", + "V\u0002\u0002\u09d6\u09d7\u0007G\u0002\u0002\u09d7\u09d8\u0007F\u0002", + "\u0002\u09d8\u0194\u0003\u0002\u0002\u0002\u09d9\u09da\u0007G\u0002", + "\u0002\u09da\u09db\u0007P\u0002\u0002\u09db\u09dc\u0007W\u0002\u0002", + "\u09dc\u09dd\u0007O\u0002\u0002\u09dd\u0196\u0003\u0002\u0002\u0002", + "\u09de\u09df\u0007G\u0002\u0002\u09df\u09e0\u0007U\u0002\u0002\u09e0", + "\u09e1\u0007E\u0002\u0002\u09e1\u09e2\u0007C\u0002\u0002\u09e2\u09e3", + "\u0007R\u0002\u0002\u09e3\u09e4\u0007G\u0002\u0002\u09e4\u0198\u0003", + "\u0002\u0002\u0002\u09e5\u09e6\u0007G\u0002\u0002\u09e6\u09e7\u0007", + "X\u0002\u0002\u09e7\u09e8\u0007G\u0002\u0002\u09e8\u09e9\u0007P\u0002", + "\u0002\u09e9\u09ea\u0007V\u0002\u0002\u09ea\u019a\u0003\u0002\u0002", + "\u0002\u09eb\u09ec\u0007G\u0002\u0002\u09ec\u09ed\u0007Z\u0002\u0002", + "\u09ed\u09ee\u0007E\u0002\u0002\u09ee\u09ef\u0007N\u0002\u0002\u09ef", + "\u09f0\u0007W\u0002\u0002\u09f0\u09f1\u0007F\u0002\u0002\u09f1\u09f2", + "\u0007G\u0002\u0002\u09f2\u019c\u0003\u0002\u0002\u0002\u09f3\u09f4", + "\u0007G\u0002\u0002\u09f4\u09f5\u0007Z\u0002\u0002\u09f5\u09f6\u0007", + "E\u0002\u0002\u09f6\u09f7\u0007N\u0002\u0002\u09f7\u09f8\u0007W\u0002", + "\u0002\u09f8\u09f9\u0007F\u0002\u0002\u09f9\u09fa\u0007K\u0002\u0002", + "\u09fa\u09fb\u0007P\u0002\u0002\u09fb\u09fc\u0007I\u0002\u0002\u09fc", + "\u019e\u0003\u0002\u0002\u0002\u09fd\u09fe\u0007G\u0002\u0002\u09fe", + "\u09ff\u0007Z\u0002\u0002\u09ff\u0a00\u0007E\u0002\u0002\u0a00\u0a01", + "\u0007N\u0002\u0002\u0a01\u0a02\u0007W\u0002\u0002\u0a02\u0a03\u0007", + "U\u0002\u0002\u0a03\u0a04\u0007K\u0002\u0002\u0a04\u0a05\u0007X\u0002", + "\u0002\u0a05\u0a06\u0007G\u0002\u0002\u0a06\u01a0\u0003\u0002\u0002", + "\u0002\u0a07\u0a08\u0007G\u0002\u0002\u0a08\u0a09\u0007Z\u0002\u0002", + "\u0a09\u0a0a\u0007G\u0002\u0002\u0a0a\u0a0b\u0007E\u0002\u0002\u0a0b", + "\u0a0c\u0007W\u0002\u0002\u0a0c\u0a0d\u0007V\u0002\u0002\u0a0d\u0a0e", + "\u0007G\u0002\u0002\u0a0e\u01a2\u0003\u0002\u0002\u0002\u0a0f\u0a10", + "\u0007G\u0002\u0002\u0a10\u0a11\u0007Z\u0002\u0002\u0a11\u0a12\u0007", + "R\u0002\u0002\u0a12\u0a13\u0007N\u0002\u0002\u0a13\u0a14\u0007C\u0002", + "\u0002\u0a14\u0a15\u0007K\u0002\u0002\u0a15\u0a16\u0007P\u0002\u0002", + "\u0a16\u01a4\u0003\u0002\u0002\u0002\u0a17\u0a18\u0007G\u0002\u0002", + "\u0a18\u0a19\u0007Z\u0002\u0002\u0a19\u0a1a\u0007V\u0002\u0002\u0a1a", + "\u0a1b\u0007G\u0002\u0002\u0a1b\u0a1c\u0007P\u0002\u0002\u0a1c\u0a1d", + "\u0007U\u0002\u0002\u0a1d\u0a1e\u0007K\u0002\u0002\u0a1e\u0a1f\u0007", + "Q\u0002\u0002\u0a1f\u0a20\u0007P\u0002\u0002\u0a20\u01a6\u0003\u0002", + "\u0002\u0002\u0a21\u0a22\u0007G\u0002\u0002\u0a22\u0a23\u0007Z\u0002", + "\u0002\u0a23\u0a24\u0007V\u0002\u0002\u0a24\u0a25\u0007G\u0002\u0002", + "\u0a25\u0a26\u0007T\u0002\u0002\u0a26\u0a27\u0007P\u0002\u0002\u0a27", + "\u0a28\u0007C\u0002\u0002\u0a28\u0a29\u0007N\u0002\u0002\u0a29\u01a8", + "\u0003\u0002\u0002\u0002\u0a2a\u0a2b\u0007H\u0002\u0002\u0a2b\u0a2c", + "\u0007C\u0002\u0002\u0a2c\u0a2d\u0007O\u0002\u0002\u0a2d\u0a2e\u0007", + "K\u0002\u0002\u0a2e\u0a2f\u0007N\u0002\u0002\u0a2f\u0a30\u0007[\u0002", + "\u0002\u0a30\u01aa\u0003\u0002\u0002\u0002\u0a31\u0a32\u0007H\u0002", + "\u0002\u0a32\u0a33\u0007K\u0002\u0002\u0a33\u0a34\u0007T\u0002\u0002", + "\u0a34\u0a35\u0007U\u0002\u0002\u0a35\u0a36\u0007V\u0002\u0002\u0a36", + "\u01ac\u0003\u0002\u0002\u0002\u0a37\u0a38\u0007H\u0002\u0002\u0a38", + "\u0a39\u0007Q\u0002\u0002\u0a39\u0a3a\u0007N\u0002\u0002\u0a3a\u0a3b", + "\u0007N\u0002\u0002\u0a3b\u0a3c\u0007Q\u0002\u0002\u0a3c\u0a3d\u0007", + "Y\u0002\u0002\u0a3d\u0a3e\u0007K\u0002\u0002\u0a3e\u0a3f\u0007P\u0002", + "\u0002\u0a3f\u0a40\u0007I\u0002\u0002\u0a40\u01ae\u0003\u0002\u0002", + "\u0002\u0a41\u0a42\u0007H\u0002\u0002\u0a42\u0a43\u0007Q\u0002\u0002", + "\u0a43\u0a44\u0007T\u0002\u0002\u0a44\u0a45\u0007E\u0002\u0002\u0a45", + "\u0a46\u0007G\u0002\u0002\u0a46\u01b0\u0003\u0002\u0002\u0002\u0a47", + "\u0a48\u0007H\u0002\u0002\u0a48\u0a49\u0007Q\u0002\u0002\u0a49\u0a4a", + "\u0007T\u0002\u0002\u0a4a\u0a4b\u0007Y\u0002\u0002\u0a4b\u0a4c\u0007", + "C\u0002\u0002\u0a4c\u0a4d\u0007T\u0002\u0002\u0a4d\u0a4e\u0007F\u0002", + "\u0002\u0a4e\u01b2\u0003\u0002\u0002\u0002\u0a4f\u0a50\u0007H\u0002", + "\u0002\u0a50\u0a51\u0007W\u0002\u0002\u0a51\u0a52\u0007P\u0002\u0002", + "\u0a52\u0a53\u0007E\u0002\u0002\u0a53\u0a54\u0007V\u0002\u0002\u0a54", + "\u0a55\u0007K\u0002\u0002\u0a55\u0a56\u0007Q\u0002\u0002\u0a56\u0a57", + "\u0007P\u0002\u0002\u0a57\u01b4\u0003\u0002\u0002\u0002\u0a58\u0a59", + "\u0007H\u0002\u0002\u0a59\u0a5a\u0007W\u0002\u0002\u0a5a\u0a5b\u0007", + "P\u0002\u0002\u0a5b\u0a5c\u0007E\u0002\u0002\u0a5c\u0a5d\u0007V\u0002", + "\u0002\u0a5d\u0a5e\u0007K\u0002\u0002\u0a5e\u0a5f\u0007Q\u0002\u0002", + "\u0a5f\u0a60\u0007P\u0002\u0002\u0a60\u0a61\u0007U\u0002\u0002\u0a61", + "\u01b6\u0003\u0002\u0002\u0002\u0a62\u0a63\u0007I\u0002\u0002\u0a63", + "\u0a64\u0007N\u0002\u0002\u0a64\u0a65\u0007Q\u0002\u0002\u0a65\u0a66", + "\u0007D\u0002\u0002\u0a66\u0a67\u0007C\u0002\u0002\u0a67\u0a68\u0007", + "N\u0002\u0002\u0a68\u01b8\u0003\u0002\u0002\u0002\u0a69\u0a6a\u0007", + "I\u0002\u0002\u0a6a\u0a6b\u0007T\u0002\u0002\u0a6b\u0a6c\u0007C\u0002", + "\u0002\u0a6c\u0a6d\u0007P\u0002\u0002\u0a6d\u0a6e\u0007V\u0002\u0002", + "\u0a6e\u0a6f\u0007G\u0002\u0002\u0a6f\u0a70\u0007F\u0002\u0002\u0a70", + "\u01ba\u0003\u0002\u0002\u0002\u0a71\u0a72\u0007J\u0002\u0002\u0a72", + "\u0a73\u0007C\u0002\u0002\u0a73\u0a74\u0007P\u0002\u0002\u0a74\u0a75", + "\u0007F\u0002\u0002\u0a75\u0a76\u0007N\u0002\u0002\u0a76\u0a77\u0007", + "G\u0002\u0002\u0a77\u0a78\u0007T\u0002\u0002\u0a78\u01bc\u0003\u0002", + "\u0002\u0002\u0a79\u0a7a\u0007J\u0002\u0002\u0a7a\u0a7b\u0007G\u0002", + "\u0002\u0a7b\u0a7c\u0007C\u0002\u0002\u0a7c\u0a7d\u0007F\u0002\u0002", + "\u0a7d\u0a7e\u0007G\u0002\u0002\u0a7e\u0a7f\u0007T\u0002\u0002\u0a7f", + "\u01be\u0003\u0002\u0002\u0002\u0a80\u0a81\u0007J\u0002\u0002\u0a81", + "\u0a82\u0007Q\u0002\u0002\u0a82\u0a83\u0007N\u0002\u0002\u0a83\u0a84", + "\u0007F\u0002\u0002\u0a84\u01c0\u0003\u0002\u0002\u0002\u0a85\u0a86", + "\u0007J\u0002\u0002\u0a86\u0a87\u0007Q\u0002\u0002\u0a87\u0a88\u0007", + "W\u0002\u0002\u0a88\u0a89\u0007T\u0002\u0002\u0a89\u01c2\u0003\u0002", + "\u0002\u0002\u0a8a\u0a8b\u0007K\u0002\u0002\u0a8b\u0a8c\u0007F\u0002", + "\u0002\u0a8c\u0a8d\u0007G\u0002\u0002\u0a8d\u0a8e\u0007P\u0002\u0002", + "\u0a8e\u0a8f\u0007V\u0002\u0002\u0a8f\u0a90\u0007K\u0002\u0002\u0a90", + "\u0a91\u0007V\u0002\u0002\u0a91\u0a92\u0007[\u0002\u0002\u0a92\u01c4", + "\u0003\u0002\u0002\u0002\u0a93\u0a94\u0007K\u0002\u0002\u0a94\u0a95", + "\u0007H\u0002\u0002\u0a95\u01c6\u0003\u0002\u0002\u0002\u0a96\u0a97", + "\u0007K\u0002\u0002\u0a97\u0a98\u0007O\u0002\u0002\u0a98\u0a99\u0007", + "O\u0002\u0002\u0a99\u0a9a\u0007G\u0002\u0002\u0a9a\u0a9b\u0007F\u0002", + "\u0002\u0a9b\u0a9c\u0007K\u0002\u0002\u0a9c\u0a9d\u0007C\u0002\u0002", + "\u0a9d\u0a9e\u0007V\u0002\u0002\u0a9e\u0a9f\u0007G\u0002\u0002\u0a9f", + "\u01c8\u0003\u0002\u0002\u0002\u0aa0\u0aa1\u0007K\u0002\u0002\u0aa1", + "\u0aa2\u0007O\u0002\u0002\u0aa2\u0aa3\u0007O\u0002\u0002\u0aa3\u0aa4", + "\u0007W\u0002\u0002\u0aa4\u0aa5\u0007V\u0002\u0002\u0aa5\u0aa6\u0007", + "C\u0002\u0002\u0aa6\u0aa7\u0007D\u0002\u0002\u0aa7\u0aa8\u0007N\u0002", + "\u0002\u0aa8\u0aa9\u0007G\u0002\u0002\u0aa9\u01ca\u0003\u0002\u0002", + "\u0002\u0aaa\u0aab\u0007K\u0002\u0002\u0aab\u0aac\u0007O\u0002\u0002", + "\u0aac\u0aad\u0007R\u0002\u0002\u0aad\u0aae\u0007N\u0002\u0002\u0aae", + "\u0aaf\u0007K\u0002\u0002\u0aaf\u0ab0\u0007E\u0002\u0002\u0ab0\u0ab1", + "\u0007K\u0002\u0002\u0ab1\u0ab2\u0007V\u0002\u0002\u0ab2\u01cc\u0003", + "\u0002\u0002\u0002\u0ab3\u0ab4\u0007K\u0002\u0002\u0ab4\u0ab5\u0007", + "P\u0002\u0002\u0ab5\u0ab6\u0007E\u0002\u0002\u0ab6\u0ab7\u0007N\u0002", + "\u0002\u0ab7\u0ab8\u0007W\u0002\u0002\u0ab8\u0ab9\u0007F\u0002\u0002", + "\u0ab9\u0aba\u0007K\u0002\u0002\u0aba\u0abb\u0007P\u0002\u0002\u0abb", + "\u0abc\u0007I\u0002\u0002\u0abc\u01ce\u0003\u0002\u0002\u0002\u0abd", + "\u0abe\u0007K\u0002\u0002\u0abe\u0abf\u0007P\u0002\u0002\u0abf\u0ac0", + "\u0007E\u0002\u0002\u0ac0\u0ac1\u0007T\u0002\u0002\u0ac1\u0ac2\u0007", + "G\u0002\u0002\u0ac2\u0ac3\u0007O\u0002\u0002\u0ac3\u0ac4\u0007G\u0002", + "\u0002\u0ac4\u0ac5\u0007P\u0002\u0002\u0ac5\u0ac6\u0007V\u0002\u0002", + "\u0ac6\u01d0\u0003\u0002\u0002\u0002\u0ac7\u0ac8\u0007K\u0002\u0002", + "\u0ac8\u0ac9\u0007P\u0002\u0002\u0ac9\u0aca\u0007F\u0002\u0002\u0aca", + "\u0acb\u0007G\u0002\u0002\u0acb\u0acc\u0007Z\u0002\u0002\u0acc\u01d2", + "\u0003\u0002\u0002\u0002\u0acd\u0ace\u0007K\u0002\u0002\u0ace\u0acf", + "\u0007P\u0002\u0002\u0acf\u0ad0\u0007F\u0002\u0002\u0ad0\u0ad1\u0007", + "G\u0002\u0002\u0ad1\u0ad2\u0007Z\u0002\u0002\u0ad2\u0ad3\u0007G\u0002", + "\u0002\u0ad3\u0ad4\u0007U\u0002\u0002\u0ad4\u01d4\u0003\u0002\u0002", + "\u0002\u0ad5\u0ad6\u0007K\u0002\u0002\u0ad6\u0ad7\u0007P\u0002\u0002", + "\u0ad7\u0ad8\u0007J\u0002\u0002\u0ad8\u0ad9\u0007G\u0002\u0002\u0ad9", + "\u0ada\u0007T\u0002\u0002\u0ada\u0adb\u0007K\u0002\u0002\u0adb\u0adc", + "\u0007V\u0002\u0002\u0adc\u01d6\u0003\u0002\u0002\u0002\u0add\u0ade", + "\u0007K\u0002\u0002\u0ade\u0adf\u0007P\u0002\u0002\u0adf\u0ae0\u0007", + "J\u0002\u0002\u0ae0\u0ae1\u0007G\u0002\u0002\u0ae1\u0ae2\u0007T\u0002", + "\u0002\u0ae2\u0ae3\u0007K\u0002\u0002\u0ae3\u0ae4\u0007V\u0002\u0002", + "\u0ae4\u0ae5\u0007U\u0002\u0002\u0ae5\u01d8\u0003\u0002\u0002\u0002", + "\u0ae6\u0ae7\u0007K\u0002\u0002\u0ae7\u0ae8\u0007P\u0002\u0002\u0ae8", + "\u0ae9\u0007N\u0002\u0002\u0ae9\u0aea\u0007K\u0002\u0002\u0aea\u0aeb", + "\u0007P\u0002\u0002\u0aeb\u0aec\u0007G\u0002\u0002\u0aec\u01da\u0003", + "\u0002\u0002\u0002\u0aed\u0aee\u0007K\u0002\u0002\u0aee\u0aef\u0007", + "P\u0002\u0002\u0aef\u0af0\u0007U\u0002\u0002\u0af0\u0af1\u0007G\u0002", + "\u0002\u0af1\u0af2\u0007P\u0002\u0002\u0af2\u0af3\u0007U\u0002\u0002", + "\u0af3\u0af4\u0007K\u0002\u0002\u0af4\u0af5\u0007V\u0002\u0002\u0af5", + "\u0af6\u0007K\u0002\u0002\u0af6\u0af7\u0007X\u0002\u0002\u0af7\u0af8", + "\u0007G\u0002\u0002\u0af8\u01dc\u0003\u0002\u0002\u0002\u0af9\u0afa", + "\u0007K\u0002\u0002\u0afa\u0afb\u0007P\u0002\u0002\u0afb\u0afc\u0007", + "U\u0002\u0002\u0afc\u0afd\u0007G\u0002\u0002\u0afd\u0afe\u0007T\u0002", + "\u0002\u0afe\u0aff\u0007V\u0002\u0002\u0aff\u01de\u0003\u0002\u0002", + "\u0002\u0b00\u0b01\u0007K\u0002\u0002\u0b01\u0b02\u0007P\u0002\u0002", + "\u0b02\u0b03\u0007U\u0002\u0002\u0b03\u0b04\u0007V\u0002\u0002\u0b04", + "\u0b05\u0007G\u0002\u0002\u0b05\u0b06\u0007C\u0002\u0002\u0b06\u0b07", + "\u0007F\u0002\u0002\u0b07\u01e0\u0003\u0002\u0002\u0002\u0b08\u0b09", + "\u0007K\u0002\u0002\u0b09\u0b0a\u0007P\u0002\u0002\u0b0a\u0b0b\u0007", + "X\u0002\u0002\u0b0b\u0b0c\u0007Q\u0002\u0002\u0b0c\u0b0d\u0007M\u0002", + "\u0002\u0b0d\u0b0e\u0007G\u0002\u0002\u0b0e\u0b0f\u0007T\u0002\u0002", + "\u0b0f\u01e2\u0003\u0002\u0002\u0002\u0b10\u0b11\u0007K\u0002\u0002", + "\u0b11\u0b12\u0007U\u0002\u0002\u0b12\u0b13\u0007Q\u0002\u0002\u0b13", + "\u0b14\u0007N\u0002\u0002\u0b14\u0b15\u0007C\u0002\u0002\u0b15\u0b16", + "\u0007V\u0002\u0002\u0b16\u0b17\u0007K\u0002\u0002\u0b17\u0b18\u0007", + "Q\u0002\u0002\u0b18\u0b19\u0007P\u0002\u0002\u0b19\u01e4\u0003\u0002", + "\u0002\u0002\u0b1a\u0b1b\u0007M\u0002\u0002\u0b1b\u0b1c\u0007G\u0002", + "\u0002\u0b1c\u0b1d\u0007[\u0002\u0002\u0b1d\u01e6\u0003\u0002\u0002", + "\u0002\u0b1e\u0b1f\u0007N\u0002\u0002\u0b1f\u0b20\u0007C\u0002\u0002", + "\u0b20\u0b21\u0007D\u0002\u0002\u0b21\u0b22\u0007G\u0002\u0002\u0b22", + "\u0b23\u0007N\u0002\u0002\u0b23\u01e8\u0003\u0002\u0002\u0002\u0b24", + "\u0b25\u0007N\u0002\u0002\u0b25\u0b26\u0007C\u0002\u0002\u0b26\u0b27", + "\u0007P\u0002\u0002\u0b27\u0b28\u0007I\u0002\u0002\u0b28\u0b29\u0007", + "W\u0002\u0002\u0b29\u0b2a\u0007C\u0002\u0002\u0b2a\u0b2b\u0007I\u0002", + "\u0002\u0b2b\u0b2c\u0007G\u0002\u0002\u0b2c\u01ea\u0003\u0002\u0002", + "\u0002\u0b2d\u0b2e\u0007N\u0002\u0002\u0b2e\u0b2f\u0007C\u0002\u0002", + "\u0b2f\u0b30\u0007T\u0002\u0002\u0b30\u0b31\u0007I\u0002\u0002\u0b31", + "\u0b32\u0007G\u0002\u0002\u0b32\u01ec\u0003\u0002\u0002\u0002\u0b33", + "\u0b34\u0007N\u0002\u0002\u0b34\u0b35\u0007C\u0002\u0002\u0b35\u0b36", + "\u0007U\u0002\u0002\u0b36\u0b37\u0007V\u0002\u0002\u0b37\u01ee\u0003", + "\u0002\u0002\u0002\u0b38\u0b39\u0007N\u0002\u0002\u0b39\u0b3a\u0007", + "G\u0002\u0002\u0b3a\u0b3b\u0007C\u0002\u0002\u0b3b\u0b3c\u0007M\u0002", + "\u0002\u0b3c\u0b3d\u0007R\u0002\u0002\u0b3d\u0b3e\u0007T\u0002\u0002", + "\u0b3e\u0b3f\u0007Q\u0002\u0002\u0b3f\u0b40\u0007Q\u0002\u0002\u0b40", + "\u0b41\u0007H\u0002\u0002\u0b41\u01f0\u0003\u0002\u0002\u0002\u0b42", + "\u0b43\u0007N\u0002\u0002\u0b43\u0b44\u0007G\u0002\u0002\u0b44\u0b45", + "\u0007X\u0002\u0002\u0b45\u0b46\u0007G\u0002\u0002\u0b46\u0b47\u0007", + "N\u0002\u0002\u0b47\u01f2\u0003\u0002\u0002\u0002\u0b48\u0b49\u0007", + "N\u0002\u0002\u0b49\u0b4a\u0007K\u0002\u0002\u0b4a\u0b4b\u0007U\u0002", + "\u0002\u0b4b\u0b4c\u0007V\u0002\u0002\u0b4c\u0b4d\u0007G\u0002\u0002", + "\u0b4d\u0b4e\u0007P\u0002\u0002\u0b4e\u01f4\u0003\u0002\u0002\u0002", + "\u0b4f\u0b50\u0007N\u0002\u0002\u0b50\u0b51\u0007Q\u0002\u0002\u0b51", + "\u0b52\u0007C\u0002\u0002\u0b52\u0b53\u0007F\u0002\u0002\u0b53\u01f6", + "\u0003\u0002\u0002\u0002\u0b54\u0b55\u0007N\u0002\u0002\u0b55\u0b56", + "\u0007Q\u0002\u0002\u0b56\u0b57\u0007E\u0002\u0002\u0b57\u0b58\u0007", + "C\u0002\u0002\u0b58\u0b59\u0007N\u0002\u0002\u0b59\u01f8\u0003\u0002", + "\u0002\u0002\u0b5a\u0b5b\u0007N\u0002\u0002\u0b5b\u0b5c\u0007Q\u0002", + "\u0002\u0b5c\u0b5d\u0007E\u0002\u0002\u0b5d\u0b5e\u0007C\u0002\u0002", + "\u0b5e\u0b5f\u0007V\u0002\u0002\u0b5f\u0b60\u0007K\u0002\u0002\u0b60", + "\u0b61\u0007Q\u0002\u0002\u0b61\u0b62\u0007P\u0002\u0002\u0b62\u01fa", + "\u0003\u0002\u0002\u0002\u0b63\u0b64\u0007N\u0002\u0002\u0b64\u0b65", + "\u0007Q\u0002\u0002\u0b65\u0b66\u0007E\u0002\u0002\u0b66\u0b67\u0007", + "M\u0002\u0002\u0b67\u01fc\u0003\u0002\u0002\u0002\u0b68\u0b69\u0007", + "O\u0002\u0002\u0b69\u0b6a\u0007C\u0002\u0002\u0b6a\u0b6b\u0007R\u0002", + "\u0002\u0b6b\u0b6c\u0007R\u0002\u0002\u0b6c\u0b6d\u0007K\u0002\u0002", + "\u0b6d\u0b6e\u0007P\u0002\u0002\u0b6e\u0b6f\u0007I\u0002\u0002\u0b6f", + "\u01fe\u0003\u0002\u0002\u0002\u0b70\u0b71\u0007O\u0002\u0002\u0b71", + "\u0b72\u0007C\u0002\u0002\u0b72\u0b73\u0007V\u0002\u0002\u0b73\u0b74", + "\u0007E\u0002\u0002\u0b74\u0b75\u0007J\u0002\u0002\u0b75\u0200\u0003", + "\u0002\u0002\u0002\u0b76\u0b77\u0007O\u0002\u0002\u0b77\u0b78\u0007", + "C\u0002\u0002\u0b78\u0b79\u0007V\u0002\u0002\u0b79\u0b7a\u0007G\u0002", + "\u0002\u0b7a\u0b7b\u0007T\u0002\u0002\u0b7b\u0b7c\u0007K\u0002\u0002", + "\u0b7c\u0b7d\u0007C\u0002\u0002\u0b7d\u0b7e\u0007N\u0002\u0002\u0b7e", + "\u0b7f\u0007K\u0002\u0002\u0b7f\u0b80\u0007\\\u0002\u0002\u0b80\u0b81", + "\u0007G\u0002\u0002\u0b81\u0b82\u0007F\u0002\u0002\u0b82\u0202\u0003", + "\u0002\u0002\u0002\u0b83\u0b84\u0007O\u0002\u0002\u0b84\u0b85\u0007", + "C\u0002\u0002\u0b85\u0b86\u0007Z\u0002\u0002\u0b86\u0b87\u0007X\u0002", + "\u0002\u0b87\u0b88\u0007C\u0002\u0002\u0b88\u0b89\u0007N\u0002\u0002", + "\u0b89\u0b8a\u0007W\u0002\u0002\u0b8a\u0b8b\u0007G\u0002\u0002\u0b8b", + "\u0204\u0003\u0002\u0002\u0002\u0b8c\u0b8d\u0007O\u0002\u0002\u0b8d", + "\u0b8e\u0007K\u0002\u0002\u0b8e\u0b8f\u0007P\u0002\u0002\u0b8f\u0b90", + "\u0007W\u0002\u0002\u0b90\u0b91\u0007V\u0002\u0002\u0b91\u0b92\u0007", + "G\u0002\u0002\u0b92\u0206\u0003\u0002\u0002\u0002\u0b93\u0b94\u0007", + "O\u0002\u0002\u0b94\u0b95\u0007K\u0002\u0002\u0b95\u0b96\u0007P\u0002", + "\u0002\u0b96\u0b97\u0007X\u0002\u0002\u0b97\u0b98\u0007C\u0002\u0002", + "\u0b98\u0b99\u0007N\u0002\u0002\u0b99\u0b9a\u0007W\u0002\u0002\u0b9a", + "\u0b9b\u0007G\u0002\u0002\u0b9b\u0208\u0003\u0002\u0002\u0002\u0b9c", + "\u0b9d\u0007O\u0002\u0002\u0b9d\u0b9e\u0007Q\u0002\u0002\u0b9e\u0b9f", + "\u0007F\u0002\u0002\u0b9f\u0ba0\u0007G\u0002\u0002\u0ba0\u020a\u0003", + "\u0002\u0002\u0002\u0ba1\u0ba2\u0007O\u0002\u0002\u0ba2\u0ba3\u0007", + "Q\u0002\u0002\u0ba3\u0ba4\u0007P\u0002\u0002\u0ba4\u0ba5\u0007V\u0002", + "\u0002\u0ba5\u0ba6\u0007J\u0002\u0002\u0ba6\u020c\u0003\u0002\u0002", + "\u0002\u0ba7\u0ba8\u0007O\u0002\u0002\u0ba8\u0ba9\u0007Q\u0002\u0002", + "\u0ba9\u0baa\u0007X\u0002\u0002\u0baa\u0bab\u0007G\u0002\u0002\u0bab", + "\u020e\u0003\u0002\u0002\u0002\u0bac\u0bad\u0007P\u0002\u0002\u0bad", + "\u0bae\u0007C\u0002\u0002\u0bae\u0baf\u0007O\u0002\u0002\u0baf\u0bb0", + "\u0007G\u0002\u0002\u0bb0\u0210\u0003\u0002\u0002\u0002\u0bb1\u0bb2", + "\u0007P\u0002\u0002\u0bb2\u0bb3\u0007C\u0002\u0002\u0bb3\u0bb4\u0007", + "O\u0002\u0002\u0bb4\u0bb5\u0007G\u0002\u0002\u0bb5\u0bb6\u0007U\u0002", + "\u0002\u0bb6\u0212\u0003\u0002\u0002\u0002\u0bb7\u0bb8\u0007P\u0002", + "\u0002\u0bb8\u0bb9\u0007G\u0002\u0002\u0bb9\u0bba\u0007Z\u0002\u0002", + "\u0bba\u0bbb\u0007V\u0002\u0002\u0bbb\u0214\u0003\u0002\u0002\u0002", + "\u0bbc\u0bbd\u0007P\u0002\u0002\u0bbd\u0bbe\u0007Q\u0002\u0002\u0bbe", + "\u0216\u0003\u0002\u0002\u0002\u0bbf\u0bc0\u0007P\u0002\u0002\u0bc0", + "\u0bc1\u0007Q\u0002\u0002\u0bc1\u0bc2\u0007V\u0002\u0002\u0bc2\u0bc3", + "\u0007J\u0002\u0002\u0bc3\u0bc4\u0007K\u0002\u0002\u0bc4\u0bc5\u0007", + "P\u0002\u0002\u0bc5\u0bc6\u0007I\u0002\u0002\u0bc6\u0218\u0003\u0002", + "\u0002\u0002\u0bc7\u0bc8\u0007P\u0002\u0002\u0bc8\u0bc9\u0007Q\u0002", + "\u0002\u0bc9\u0bca\u0007V\u0002\u0002\u0bca\u0bcb\u0007K\u0002\u0002", + "\u0bcb\u0bcc\u0007H\u0002\u0002\u0bcc\u0bcd\u0007[\u0002\u0002\u0bcd", + "\u021a\u0003\u0002\u0002\u0002\u0bce\u0bcf\u0007P\u0002\u0002\u0bcf", + "\u0bd0\u0007Q\u0002\u0002\u0bd0\u0bd1\u0007Y\u0002\u0002\u0bd1\u0bd2", + "\u0007C\u0002\u0002\u0bd2\u0bd3\u0007K\u0002\u0002\u0bd3\u0bd4\u0007", + "V\u0002\u0002\u0bd4\u021c\u0003\u0002\u0002\u0002\u0bd5\u0bd6\u0007", + "P\u0002\u0002\u0bd6\u0bd7\u0007W\u0002\u0002\u0bd7\u0bd8\u0007N\u0002", + "\u0002\u0bd8\u0bd9\u0007N\u0002\u0002\u0bd9\u0bda\u0007U\u0002\u0002", + "\u0bda\u021e\u0003\u0002\u0002\u0002\u0bdb\u0bdc\u0007Q\u0002\u0002", + "\u0bdc\u0bdd\u0007D\u0002\u0002\u0bdd\u0bde\u0007L\u0002\u0002\u0bde", + "\u0bdf\u0007G\u0002\u0002\u0bdf\u0be0\u0007E\u0002\u0002\u0be0\u0be1", + "\u0007V\u0002\u0002\u0be1\u0220\u0003\u0002\u0002\u0002\u0be2\u0be3", + "\u0007Q\u0002\u0002\u0be3\u0be4\u0007H\u0002\u0002\u0be4\u0222\u0003", + "\u0002\u0002\u0002\u0be5\u0be6\u0007Q\u0002\u0002\u0be6\u0be7\u0007", + "H\u0002\u0002\u0be7\u0be8\u0007H\u0002\u0002\u0be8\u0224\u0003\u0002", + "\u0002\u0002\u0be9\u0bea\u0007Q\u0002\u0002\u0bea\u0beb\u0007K\u0002", + "\u0002\u0beb\u0bec\u0007F\u0002\u0002\u0bec\u0bed\u0007U\u0002\u0002", + "\u0bed\u0226\u0003\u0002\u0002\u0002\u0bee\u0bef\u0007Q\u0002\u0002", + "\u0bef\u0bf0\u0007R\u0002\u0002\u0bf0\u0bf1\u0007G\u0002\u0002\u0bf1", + "\u0bf2\u0007T\u0002\u0002\u0bf2\u0bf3\u0007C\u0002\u0002\u0bf3\u0bf4", + "\u0007V\u0002\u0002\u0bf4\u0bf5\u0007Q\u0002\u0002\u0bf5\u0bf6\u0007", + "T\u0002\u0002\u0bf6\u0228\u0003\u0002\u0002\u0002\u0bf7\u0bf8\u0007", + "Q\u0002\u0002\u0bf8\u0bf9\u0007R\u0002\u0002\u0bf9\u0bfa\u0007V\u0002", + "\u0002\u0bfa\u0bfb\u0007K\u0002\u0002\u0bfb\u0bfc\u0007Q\u0002\u0002", + "\u0bfc\u0bfd\u0007P\u0002\u0002\u0bfd\u022a\u0003\u0002\u0002\u0002", + "\u0bfe\u0bff\u0007Q\u0002\u0002\u0bff\u0c00\u0007R\u0002\u0002\u0c00", + "\u0c01\u0007V\u0002\u0002\u0c01\u0c02\u0007K\u0002\u0002\u0c02\u0c03", + "\u0007Q\u0002\u0002\u0c03\u0c04\u0007P\u0002\u0002\u0c04\u0c05\u0007", + "U\u0002\u0002\u0c05\u022c\u0003\u0002\u0002\u0002\u0c06\u0c07\u0007", + "Q\u0002\u0002\u0c07\u0c08\u0007Y\u0002\u0002\u0c08\u0c09\u0007P\u0002", + "\u0002\u0c09\u0c0a\u0007G\u0002\u0002\u0c0a\u0c0b\u0007F\u0002\u0002", + "\u0c0b\u022e\u0003\u0002\u0002\u0002\u0c0c\u0c0d\u0007Q\u0002\u0002", + "\u0c0d\u0c0e\u0007Y\u0002\u0002\u0c0e\u0c0f\u0007P\u0002\u0002\u0c0f", + "\u0c10\u0007G\u0002\u0002\u0c10\u0c11\u0007T\u0002\u0002\u0c11\u0230", + "\u0003\u0002\u0002\u0002\u0c12\u0c13\u0007R\u0002\u0002\u0c13\u0c14", + "\u0007C\u0002\u0002\u0c14\u0c15\u0007T\u0002\u0002\u0c15\u0c16\u0007", + "U\u0002\u0002\u0c16\u0c17\u0007G\u0002\u0002\u0c17\u0c18\u0007T\u0002", + "\u0002\u0c18\u0232\u0003\u0002\u0002\u0002\u0c19\u0c1a\u0007R\u0002", + "\u0002\u0c1a\u0c1b\u0007C\u0002\u0002\u0c1b\u0c1c\u0007T\u0002\u0002", + "\u0c1c\u0c1d\u0007V\u0002\u0002\u0c1d\u0c1e\u0007K\u0002\u0002\u0c1e", + "\u0c1f\u0007C\u0002\u0002\u0c1f\u0c20\u0007N\u0002\u0002\u0c20\u0234", + "\u0003\u0002\u0002\u0002\u0c21\u0c22\u0007R\u0002\u0002\u0c22\u0c23", + "\u0007C\u0002\u0002\u0c23\u0c24\u0007T\u0002\u0002\u0c24\u0c25\u0007", + "V\u0002\u0002\u0c25\u0c26\u0007K\u0002\u0002\u0c26\u0c27\u0007V\u0002", + "\u0002\u0c27\u0c28\u0007K\u0002\u0002\u0c28\u0c29\u0007Q\u0002\u0002", + "\u0c29\u0c2a\u0007P\u0002\u0002\u0c2a\u0236\u0003\u0002\u0002\u0002", + "\u0c2b\u0c2c\u0007R\u0002\u0002\u0c2c\u0c2d\u0007C\u0002\u0002\u0c2d", + "\u0c2e\u0007U\u0002\u0002\u0c2e\u0c2f\u0007U\u0002\u0002\u0c2f\u0c30", + "\u0007K\u0002\u0002\u0c30\u0c31\u0007P\u0002\u0002\u0c31\u0c32\u0007", + "I\u0002\u0002\u0c32\u0238\u0003\u0002\u0002\u0002\u0c33\u0c34\u0007", + "R\u0002\u0002\u0c34\u0c35\u0007C\u0002\u0002\u0c35\u0c36\u0007U\u0002", + "\u0002\u0c36\u0c37\u0007U\u0002\u0002\u0c37\u0c38\u0007Y\u0002\u0002", + "\u0c38\u0c39\u0007Q\u0002\u0002\u0c39\u0c3a\u0007T\u0002\u0002\u0c3a", + "\u0c3b\u0007F\u0002\u0002\u0c3b\u023a\u0003\u0002\u0002\u0002\u0c3c", + "\u0c3d\u0007R\u0002\u0002\u0c3d\u0c3e\u0007N\u0002\u0002\u0c3e\u0c3f", + "\u0007C\u0002\u0002\u0c3f\u0c40\u0007P\u0002\u0002\u0c40\u0c41\u0007", + "U\u0002\u0002\u0c41\u023c\u0003\u0002\u0002\u0002\u0c42\u0c43\u0007", + "R\u0002\u0002\u0c43\u0c44\u0007T\u0002\u0002\u0c44\u0c45\u0007G\u0002", + "\u0002\u0c45\u0c46\u0007E\u0002\u0002\u0c46\u0c47\u0007G\u0002\u0002", + "\u0c47\u0c48\u0007F\u0002\u0002\u0c48\u0c49\u0007K\u0002\u0002\u0c49", + "\u0c4a\u0007P\u0002\u0002\u0c4a\u0c4b\u0007I\u0002\u0002\u0c4b\u023e", + "\u0003\u0002\u0002\u0002\u0c4c\u0c4d\u0007R\u0002\u0002\u0c4d\u0c4e", + "\u0007T\u0002\u0002\u0c4e\u0c4f\u0007G\u0002\u0002\u0c4f\u0c50\u0007", + "R\u0002\u0002\u0c50\u0c51\u0007C\u0002\u0002\u0c51\u0c52\u0007T\u0002", + "\u0002\u0c52\u0c53\u0007G\u0002\u0002\u0c53\u0240\u0003\u0002\u0002", + "\u0002\u0c54\u0c55\u0007R\u0002\u0002\u0c55\u0c56\u0007T\u0002\u0002", + "\u0c56\u0c57\u0007G\u0002\u0002\u0c57\u0c58\u0007R\u0002\u0002\u0c58", + "\u0c59\u0007C\u0002\u0002\u0c59\u0c5a\u0007T\u0002\u0002\u0c5a\u0c5b", + "\u0007G\u0002\u0002\u0c5b\u0c5c\u0007F\u0002\u0002\u0c5c\u0242\u0003", + "\u0002\u0002\u0002\u0c5d\u0c5e\u0007R\u0002\u0002\u0c5e\u0c5f\u0007", + "T\u0002\u0002\u0c5f\u0c60\u0007G\u0002\u0002\u0c60\u0c61\u0007U\u0002", + "\u0002\u0c61\u0c62\u0007G\u0002\u0002\u0c62\u0c63\u0007T\u0002\u0002", + "\u0c63\u0c64\u0007X\u0002\u0002\u0c64\u0c65\u0007G\u0002\u0002\u0c65", + "\u0244\u0003\u0002\u0002\u0002\u0c66\u0c67\u0007R\u0002\u0002\u0c67", + "\u0c68\u0007T\u0002\u0002\u0c68\u0c69\u0007K\u0002\u0002\u0c69\u0c6a", + "\u0007Q\u0002\u0002\u0c6a\u0c6b\u0007T\u0002\u0002\u0c6b\u0246\u0003", + "\u0002\u0002\u0002\u0c6c\u0c6d\u0007R\u0002\u0002\u0c6d\u0c6e\u0007", + "T\u0002\u0002\u0c6e\u0c6f\u0007K\u0002\u0002\u0c6f\u0c70\u0007X\u0002", + "\u0002\u0c70\u0c71\u0007K\u0002\u0002\u0c71\u0c72\u0007N\u0002\u0002", + "\u0c72\u0c73\u0007G\u0002\u0002\u0c73\u0c74\u0007I\u0002\u0002\u0c74", + "\u0c75\u0007G\u0002\u0002\u0c75\u0c76\u0007U\u0002\u0002\u0c76\u0248", + "\u0003\u0002\u0002\u0002\u0c77\u0c78\u0007R\u0002\u0002\u0c78\u0c79", + "\u0007T\u0002\u0002\u0c79\u0c7a\u0007Q\u0002\u0002\u0c7a\u0c7b\u0007", + "E\u0002\u0002\u0c7b\u0c7c\u0007G\u0002\u0002\u0c7c\u0c7d\u0007F\u0002", + "\u0002\u0c7d\u0c7e\u0007W\u0002\u0002\u0c7e\u0c7f\u0007T\u0002\u0002", + "\u0c7f\u0c80\u0007C\u0002\u0002\u0c80\u0c81\u0007N\u0002\u0002\u0c81", + "\u024a\u0003\u0002\u0002\u0002\u0c82\u0c83\u0007R\u0002\u0002\u0c83", + "\u0c84\u0007T\u0002\u0002\u0c84\u0c85\u0007Q\u0002\u0002\u0c85\u0c86", + "\u0007E\u0002\u0002\u0c86\u0c87\u0007G\u0002\u0002\u0c87\u0c88\u0007", + "F\u0002\u0002\u0c88\u0c89\u0007W\u0002\u0002\u0c89\u0c8a\u0007T\u0002", + "\u0002\u0c8a\u0c8b\u0007G\u0002\u0002\u0c8b\u024c\u0003\u0002\u0002", + "\u0002\u0c8c\u0c8d\u0007R\u0002\u0002\u0c8d\u0c8e\u0007T\u0002\u0002", + "\u0c8e\u0c8f\u0007Q\u0002\u0002\u0c8f\u0c90\u0007I\u0002\u0002\u0c90", + "\u0c91\u0007T\u0002\u0002\u0c91\u0c92\u0007C\u0002\u0002\u0c92\u0c93", + "\u0007O\u0002\u0002\u0c93\u024e\u0003\u0002\u0002\u0002\u0c94\u0c95", + "\u0007S\u0002\u0002\u0c95\u0c96\u0007W\u0002\u0002\u0c96\u0c97\u0007", + "Q\u0002\u0002\u0c97\u0c98\u0007V\u0002\u0002\u0c98\u0c99\u0007G\u0002", + "\u0002\u0c99\u0250\u0003\u0002\u0002\u0002\u0c9a\u0c9b\u0007T\u0002", + "\u0002\u0c9b\u0c9c\u0007C\u0002\u0002\u0c9c\u0c9d\u0007P\u0002\u0002", + "\u0c9d\u0c9e\u0007I\u0002\u0002\u0c9e\u0c9f\u0007G\u0002\u0002\u0c9f", + "\u0252\u0003\u0002\u0002\u0002\u0ca0\u0ca1\u0007T\u0002\u0002\u0ca1", + "\u0ca2\u0007G\u0002\u0002\u0ca2\u0ca3\u0007C\u0002\u0002\u0ca3\u0ca4", + "\u0007F\u0002\u0002\u0ca4\u0254\u0003\u0002\u0002\u0002\u0ca5\u0ca6", + "\u0007T\u0002\u0002\u0ca6\u0ca7\u0007G\u0002\u0002\u0ca7\u0ca8\u0007", + "C\u0002\u0002\u0ca8\u0ca9\u0007U\u0002\u0002\u0ca9\u0caa\u0007U\u0002", + "\u0002\u0caa\u0cab\u0007K\u0002\u0002\u0cab\u0cac\u0007I\u0002\u0002", + "\u0cac\u0cad\u0007P\u0002\u0002\u0cad\u0256\u0003\u0002\u0002\u0002", + "\u0cae\u0caf\u0007T\u0002\u0002\u0caf\u0cb0\u0007G\u0002\u0002\u0cb0", + "\u0cb1\u0007E\u0002\u0002\u0cb1\u0cb2\u0007J\u0002\u0002\u0cb2\u0cb3", + "\u0007G\u0002\u0002\u0cb3\u0cb4\u0007E\u0002\u0002\u0cb4\u0cb5\u0007", + "M\u0002\u0002\u0cb5\u0258\u0003\u0002\u0002\u0002\u0cb6\u0cb7\u0007", + "T\u0002\u0002\u0cb7\u0cb8\u0007G\u0002\u0002\u0cb8\u0cb9\u0007E\u0002", + "\u0002\u0cb9\u0cba\u0007W\u0002\u0002\u0cba\u0cbb\u0007T\u0002\u0002", + "\u0cbb\u0cbc\u0007U\u0002\u0002\u0cbc\u0cbd\u0007K\u0002\u0002\u0cbd", + "\u0cbe\u0007X\u0002\u0002\u0cbe\u0cbf\u0007G\u0002\u0002\u0cbf\u025a", + "\u0003\u0002\u0002\u0002\u0cc0\u0cc1\u0007T\u0002\u0002\u0cc1\u0cc2", + "\u0007G\u0002\u0002\u0cc2\u0cc3\u0007H\u0002\u0002\u0cc3\u025c\u0003", + "\u0002\u0002\u0002\u0cc4\u0cc5\u0007T\u0002\u0002\u0cc5\u0cc6\u0007", + "G\u0002\u0002\u0cc6\u0cc7\u0007H\u0002\u0002\u0cc7\u0cc8\u0007T\u0002", + "\u0002\u0cc8\u0cc9\u0007G\u0002\u0002\u0cc9\u0cca\u0007U\u0002\u0002", + "\u0cca\u0ccb\u0007J\u0002\u0002\u0ccb\u025e\u0003\u0002\u0002\u0002", + "\u0ccc\u0ccd\u0007T\u0002\u0002\u0ccd\u0cce\u0007G\u0002\u0002\u0cce", + "\u0ccf\u0007K\u0002\u0002\u0ccf\u0cd0\u0007P\u0002\u0002\u0cd0\u0cd1", + "\u0007F\u0002\u0002\u0cd1\u0cd2\u0007G\u0002\u0002\u0cd2\u0cd3\u0007", + "Z\u0002\u0002\u0cd3\u0260\u0003\u0002\u0002\u0002\u0cd4\u0cd5\u0007", + "T\u0002\u0002\u0cd5\u0cd6\u0007G\u0002\u0002\u0cd6\u0cd7\u0007N\u0002", + "\u0002\u0cd7\u0cd8\u0007C\u0002\u0002\u0cd8\u0cd9\u0007V\u0002\u0002", + "\u0cd9\u0cda\u0007K\u0002\u0002\u0cda\u0cdb\u0007X\u0002\u0002\u0cdb", + "\u0cdc\u0007G\u0002\u0002\u0cdc\u0262\u0003\u0002\u0002\u0002\u0cdd", + "\u0cde\u0007T\u0002\u0002\u0cde\u0cdf\u0007G\u0002\u0002\u0cdf\u0ce0", + "\u0007N\u0002\u0002\u0ce0\u0ce1\u0007G\u0002\u0002\u0ce1\u0ce2\u0007", + "C\u0002\u0002\u0ce2\u0ce3\u0007U\u0002\u0002\u0ce3\u0ce4\u0007G\u0002", + "\u0002\u0ce4\u0264\u0003\u0002\u0002\u0002\u0ce5\u0ce6\u0007T\u0002", + "\u0002\u0ce6\u0ce7\u0007G\u0002\u0002\u0ce7\u0ce8\u0007P\u0002\u0002", + "\u0ce8\u0ce9\u0007C\u0002\u0002\u0ce9\u0cea\u0007O\u0002\u0002\u0cea", + "\u0ceb\u0007G\u0002\u0002\u0ceb\u0266\u0003\u0002\u0002\u0002\u0cec", + "\u0ced\u0007T\u0002\u0002\u0ced\u0cee\u0007G\u0002\u0002\u0cee\u0cef", + "\u0007R\u0002\u0002\u0cef\u0cf0\u0007G\u0002\u0002\u0cf0\u0cf1\u0007", + "C\u0002\u0002\u0cf1\u0cf2\u0007V\u0002\u0002\u0cf2\u0cf3\u0007C\u0002", + "\u0002\u0cf3\u0cf4\u0007D\u0002\u0002\u0cf4\u0cf5\u0007N\u0002\u0002", + "\u0cf5\u0cf6\u0007G\u0002\u0002\u0cf6\u0268\u0003\u0002\u0002\u0002", + "\u0cf7\u0cf8\u0007T\u0002\u0002\u0cf8\u0cf9\u0007G\u0002\u0002\u0cf9", + "\u0cfa\u0007R\u0002\u0002\u0cfa\u0cfb\u0007N\u0002\u0002\u0cfb\u0cfc", + "\u0007C\u0002\u0002\u0cfc\u0cfd\u0007E\u0002\u0002\u0cfd\u0cfe\u0007", + "G\u0002\u0002\u0cfe\u026a\u0003\u0002\u0002\u0002\u0cff\u0d00\u0007", + "T\u0002\u0002\u0d00\u0d01\u0007G\u0002\u0002\u0d01\u0d02\u0007R\u0002", + "\u0002\u0d02\u0d03\u0007N\u0002\u0002\u0d03\u0d04\u0007K\u0002\u0002", + "\u0d04\u0d05\u0007E\u0002\u0002\u0d05\u0d06\u0007C\u0002\u0002\u0d06", + "\u026c\u0003\u0002\u0002\u0002\u0d07\u0d08\u0007T\u0002\u0002\u0d08", + "\u0d09\u0007G\u0002\u0002\u0d09\u0d0a\u0007U\u0002\u0002\u0d0a\u0d0b", + "\u0007G\u0002\u0002\u0d0b\u0d0c\u0007V\u0002\u0002\u0d0c\u026e\u0003", + "\u0002\u0002\u0002\u0d0d\u0d0e\u0007T\u0002\u0002\u0d0e\u0d0f\u0007", + "G\u0002\u0002\u0d0f\u0d10\u0007U\u0002\u0002\u0d10\u0d11\u0007V\u0002", + "\u0002\u0d11\u0d12\u0007C\u0002\u0002\u0d12\u0d13\u0007T\u0002\u0002", + "\u0d13\u0d14\u0007V\u0002\u0002\u0d14\u0270\u0003\u0002\u0002\u0002", + "\u0d15\u0d16\u0007T\u0002\u0002\u0d16\u0d17\u0007G\u0002\u0002\u0d17", + "\u0d18\u0007U\u0002\u0002\u0d18\u0d19\u0007V\u0002\u0002\u0d19\u0d1a", + "\u0007T\u0002\u0002\u0d1a\u0d1b\u0007K\u0002\u0002\u0d1b\u0d1c\u0007", + "E\u0002\u0002\u0d1c\u0d1d\u0007V\u0002\u0002\u0d1d\u0272\u0003\u0002", + "\u0002\u0002\u0d1e\u0d1f\u0007T\u0002\u0002\u0d1f\u0d20\u0007G\u0002", + "\u0002\u0d20\u0d21\u0007V\u0002\u0002\u0d21\u0d22\u0007W\u0002\u0002", + "\u0d22\u0d23\u0007T\u0002\u0002\u0d23\u0d24\u0007P\u0002\u0002\u0d24", + "\u0d25\u0007U\u0002\u0002\u0d25\u0274\u0003\u0002\u0002\u0002\u0d26", + "\u0d27\u0007T\u0002\u0002\u0d27\u0d28\u0007G\u0002\u0002\u0d28\u0d29", + "\u0007X\u0002\u0002\u0d29\u0d2a\u0007Q\u0002\u0002\u0d2a\u0d2b\u0007", + "M\u0002\u0002\u0d2b\u0d2c\u0007G\u0002\u0002\u0d2c\u0276\u0003\u0002", + "\u0002\u0002\u0d2d\u0d2e\u0007T\u0002\u0002\u0d2e\u0d2f\u0007Q\u0002", + "\u0002\u0d2f\u0d30\u0007N\u0002\u0002\u0d30\u0d31\u0007G\u0002\u0002", + "\u0d31\u0278\u0003\u0002\u0002\u0002\u0d32\u0d33\u0007T\u0002\u0002", + "\u0d33\u0d34\u0007Q\u0002\u0002\u0d34\u0d35\u0007N\u0002\u0002\u0d35", + "\u0d36\u0007N\u0002\u0002\u0d36\u0d37\u0007D\u0002\u0002\u0d37\u0d38", + "\u0007C\u0002\u0002\u0d38\u0d39\u0007E\u0002\u0002\u0d39\u0d3a\u0007", + "M\u0002\u0002\u0d3a\u027a\u0003\u0002\u0002\u0002\u0d3b\u0d3c\u0007", + "T\u0002\u0002\u0d3c\u0d3d\u0007Q\u0002\u0002\u0d3d\u0d3e\u0007Y\u0002", + "\u0002\u0d3e\u0d3f\u0007U\u0002\u0002\u0d3f\u027c\u0003\u0002\u0002", + "\u0002\u0d40\u0d41\u0007T\u0002\u0002\u0d41\u0d42\u0007W\u0002\u0002", + "\u0d42\u0d43\u0007N\u0002\u0002\u0d43\u0d44\u0007G\u0002\u0002\u0d44", + "\u027e\u0003\u0002\u0002\u0002\u0d45\u0d46\u0007U\u0002\u0002\u0d46", + "\u0d47\u0007C\u0002\u0002\u0d47\u0d48\u0007X\u0002\u0002\u0d48\u0d49", + "\u0007G\u0002\u0002\u0d49\u0d4a\u0007R\u0002\u0002\u0d4a\u0d4b\u0007", + "Q\u0002\u0002\u0d4b\u0d4c\u0007K\u0002\u0002\u0d4c\u0d4d\u0007P\u0002", + "\u0002\u0d4d\u0d4e\u0007V\u0002\u0002\u0d4e\u0280\u0003\u0002\u0002", + "\u0002\u0d4f\u0d50\u0007U\u0002\u0002\u0d50\u0d51\u0007E\u0002\u0002", + "\u0d51\u0d52\u0007J\u0002\u0002\u0d52\u0d53\u0007G\u0002\u0002\u0d53", + "\u0d54\u0007O\u0002\u0002\u0d54\u0d55\u0007C\u0002\u0002\u0d55\u0282", + "\u0003\u0002\u0002\u0002\u0d56\u0d57\u0007U\u0002\u0002\u0d57\u0d58", + "\u0007E\u0002\u0002\u0d58\u0d59\u0007T\u0002\u0002\u0d59\u0d5a\u0007", + "Q\u0002\u0002\u0d5a\u0d5b\u0007N\u0002\u0002\u0d5b\u0d5c\u0007N\u0002", + "\u0002\u0d5c\u0284\u0003\u0002\u0002\u0002\u0d5d\u0d5e\u0007U\u0002", + "\u0002\u0d5e\u0d5f\u0007G\u0002\u0002\u0d5f\u0d60\u0007C\u0002\u0002", + "\u0d60\u0d61\u0007T\u0002\u0002\u0d61\u0d62\u0007E\u0002\u0002\u0d62", + "\u0d63\u0007J\u0002\u0002\u0d63\u0286\u0003\u0002\u0002\u0002\u0d64", + "\u0d65\u0007U\u0002\u0002\u0d65\u0d66\u0007G\u0002\u0002\u0d66\u0d67", + "\u0007E\u0002\u0002\u0d67\u0d68\u0007Q\u0002\u0002\u0d68\u0d69\u0007", + "P\u0002\u0002\u0d69\u0d6a\u0007F\u0002\u0002\u0d6a\u0288\u0003\u0002", + "\u0002\u0002\u0d6b\u0d6c\u0007U\u0002\u0002\u0d6c\u0d6d\u0007G\u0002", + "\u0002\u0d6d\u0d6e\u0007E\u0002\u0002\u0d6e\u0d6f\u0007W\u0002\u0002", + "\u0d6f\u0d70\u0007T\u0002\u0002\u0d70\u0d71\u0007K\u0002\u0002\u0d71", + "\u0d72\u0007V\u0002\u0002\u0d72\u0d73\u0007[\u0002\u0002\u0d73\u028a", + "\u0003\u0002\u0002\u0002\u0d74\u0d75\u0007U\u0002\u0002\u0d75\u0d76", + "\u0007G\u0002\u0002\u0d76\u0d77\u0007S\u0002\u0002\u0d77\u0d78\u0007", + "W\u0002\u0002\u0d78\u0d79\u0007G\u0002\u0002\u0d79\u0d7a\u0007P\u0002", + "\u0002\u0d7a\u0d7b\u0007E\u0002\u0002\u0d7b\u0d7c\u0007G\u0002\u0002", + "\u0d7c\u028c\u0003\u0002\u0002\u0002\u0d7d\u0d7e\u0007U\u0002\u0002", + "\u0d7e\u0d7f\u0007G\u0002\u0002\u0d7f\u0d80\u0007S\u0002\u0002\u0d80", + "\u0d81\u0007W\u0002\u0002\u0d81\u0d82\u0007G\u0002\u0002\u0d82\u0d83", + "\u0007P\u0002\u0002\u0d83\u0d84\u0007E\u0002\u0002\u0d84\u0d85\u0007", + "G\u0002\u0002\u0d85\u0d86\u0007U\u0002\u0002\u0d86\u028e\u0003\u0002", + "\u0002\u0002\u0d87\u0d88\u0007U\u0002\u0002\u0d88\u0d89\u0007G\u0002", + "\u0002\u0d89\u0d8a\u0007T\u0002\u0002\u0d8a\u0d8b\u0007K\u0002\u0002", + "\u0d8b\u0d8c\u0007C\u0002\u0002\u0d8c\u0d8d\u0007N\u0002\u0002\u0d8d", + "\u0d8e\u0007K\u0002\u0002\u0d8e\u0d8f\u0007\\\u0002\u0002\u0d8f\u0d90", + "\u0007C\u0002\u0002\u0d90\u0d91\u0007D\u0002\u0002\u0d91\u0d92\u0007", + "N\u0002\u0002\u0d92\u0d93\u0007G\u0002\u0002\u0d93\u0290\u0003\u0002", + "\u0002\u0002\u0d94\u0d95\u0007U\u0002\u0002\u0d95\u0d96\u0007G\u0002", + "\u0002\u0d96\u0d97\u0007T\u0002\u0002\u0d97\u0d98\u0007X\u0002\u0002", + "\u0d98\u0d99\u0007G\u0002\u0002\u0d99\u0d9a\u0007T\u0002\u0002\u0d9a", + "\u0292\u0003\u0002\u0002\u0002\u0d9b\u0d9c\u0007U\u0002\u0002\u0d9c", + "\u0d9d\u0007G\u0002\u0002\u0d9d\u0d9e\u0007U\u0002\u0002\u0d9e\u0d9f", + "\u0007U\u0002\u0002\u0d9f\u0da0\u0007K\u0002\u0002\u0da0\u0da1\u0007", + "Q\u0002\u0002\u0da1\u0da2\u0007P\u0002\u0002\u0da2\u0294\u0003\u0002", + "\u0002\u0002\u0da3\u0da4\u0007U\u0002\u0002\u0da4\u0da5\u0007G\u0002", + "\u0002\u0da5\u0da6\u0007V\u0002\u0002\u0da6\u0296\u0003\u0002\u0002", + "\u0002\u0da7\u0da8\u0007U\u0002\u0002\u0da8\u0da9\u0007J\u0002\u0002", + "\u0da9\u0daa\u0007C\u0002\u0002\u0daa\u0dab\u0007T\u0002\u0002\u0dab", + "\u0dac\u0007G\u0002\u0002\u0dac\u0298\u0003\u0002\u0002\u0002\u0dad", + "\u0dae\u0007U\u0002\u0002\u0dae\u0daf\u0007J\u0002\u0002\u0daf\u0db0", + "\u0007Q\u0002\u0002\u0db0\u0db1\u0007Y\u0002\u0002\u0db1\u029a\u0003", + "\u0002\u0002\u0002\u0db2\u0db3\u0007U\u0002\u0002\u0db3\u0db4\u0007", + "K\u0002\u0002\u0db4\u0db5\u0007O\u0002\u0002\u0db5\u0db6\u0007R\u0002", + "\u0002\u0db6\u0db7\u0007N\u0002\u0002\u0db7\u0db8\u0007G\u0002\u0002", + "\u0db8\u029c\u0003\u0002\u0002\u0002\u0db9\u0dba\u0007U\u0002\u0002", + "\u0dba\u0dbb\u0007P\u0002\u0002\u0dbb\u0dbc\u0007C\u0002\u0002\u0dbc", + "\u0dbd\u0007R\u0002\u0002\u0dbd\u0dbe\u0007U\u0002\u0002\u0dbe\u0dbf", + "\u0007J\u0002\u0002\u0dbf\u0dc0\u0007Q\u0002\u0002\u0dc0\u0dc1\u0007", + "V\u0002\u0002\u0dc1\u029e\u0003\u0002\u0002\u0002\u0dc2\u0dc3\u0007", + "U\u0002\u0002\u0dc3\u0dc4\u0007V\u0002\u0002\u0dc4\u0dc5\u0007C\u0002", + "\u0002\u0dc5\u0dc6\u0007D\u0002\u0002\u0dc6\u0dc7\u0007N\u0002\u0002", + "\u0dc7\u0dc8\u0007G\u0002\u0002\u0dc8\u02a0\u0003\u0002\u0002\u0002", + "\u0dc9\u0dca\u0007U\u0002\u0002\u0dca\u0dcb\u0007V\u0002\u0002\u0dcb", + "\u0dcc\u0007C\u0002\u0002\u0dcc\u0dcd\u0007P\u0002\u0002\u0dcd\u0dce", + "\u0007F\u0002\u0002\u0dce\u0dcf\u0007C\u0002\u0002\u0dcf\u0dd0\u0007", + "N\u0002\u0002\u0dd0\u0dd1\u0007Q\u0002\u0002\u0dd1\u0dd2\u0007P\u0002", + "\u0002\u0dd2\u0dd3\u0007G\u0002\u0002\u0dd3\u02a2\u0003\u0002\u0002", + "\u0002\u0dd4\u0dd5\u0007U\u0002\u0002\u0dd5\u0dd6\u0007V\u0002\u0002", + "\u0dd6\u0dd7\u0007C\u0002\u0002\u0dd7\u0dd8\u0007T\u0002\u0002\u0dd8", + "\u0dd9\u0007V\u0002\u0002\u0dd9\u02a4\u0003\u0002\u0002\u0002\u0dda", + "\u0ddb\u0007U\u0002\u0002\u0ddb\u0ddc\u0007V\u0002\u0002\u0ddc\u0ddd", + "\u0007C\u0002\u0002\u0ddd\u0dde\u0007V\u0002\u0002\u0dde\u0ddf\u0007", + "G\u0002\u0002\u0ddf\u0de0\u0007O\u0002\u0002\u0de0\u0de1\u0007G\u0002", + "\u0002\u0de1\u0de2\u0007P\u0002\u0002\u0de2\u0de3\u0007V\u0002\u0002", + "\u0de3\u02a6\u0003\u0002\u0002\u0002\u0de4\u0de5\u0007U\u0002\u0002", + "\u0de5\u0de6\u0007V\u0002\u0002\u0de6\u0de7\u0007C\u0002\u0002\u0de7", + "\u0de8\u0007V\u0002\u0002\u0de8\u0de9\u0007K\u0002\u0002\u0de9\u0dea", + "\u0007U\u0002\u0002\u0dea\u0deb\u0007V\u0002\u0002\u0deb\u0dec\u0007", + "K\u0002\u0002\u0dec\u0ded\u0007E\u0002\u0002\u0ded\u0dee\u0007U\u0002", + "\u0002\u0dee\u02a8\u0003\u0002\u0002\u0002\u0def\u0df0\u0007U\u0002", + "\u0002\u0df0\u0df1\u0007V\u0002\u0002\u0df1\u0df2\u0007F\u0002\u0002", + "\u0df2\u0df3\u0007K\u0002\u0002\u0df3\u0df4\u0007P\u0002\u0002\u0df4", + "\u02aa\u0003\u0002\u0002\u0002\u0df5\u0df6\u0007U\u0002\u0002\u0df6", + "\u0df7\u0007V\u0002\u0002\u0df7\u0df8\u0007F\u0002\u0002\u0df8\u0df9", + "\u0007Q\u0002\u0002\u0df9\u0dfa\u0007W\u0002\u0002\u0dfa\u0dfb\u0007", + "V\u0002\u0002\u0dfb\u02ac\u0003\u0002\u0002\u0002\u0dfc\u0dfd\u0007", + "U\u0002\u0002\u0dfd\u0dfe\u0007V\u0002\u0002\u0dfe\u0dff\u0007Q\u0002", + "\u0002\u0dff\u0e00\u0007T\u0002\u0002\u0e00\u0e01\u0007C\u0002\u0002", + "\u0e01\u0e02\u0007I\u0002\u0002\u0e02\u0e03\u0007G\u0002\u0002\u0e03", + "\u02ae\u0003\u0002\u0002\u0002\u0e04\u0e05\u0007U\u0002\u0002\u0e05", + "\u0e06\u0007V\u0002\u0002\u0e06\u0e07\u0007T\u0002\u0002\u0e07\u0e08", + "\u0007K\u0002\u0002\u0e08\u0e09\u0007E\u0002\u0002\u0e09\u0e0a\u0007", + "V\u0002\u0002\u0e0a\u02b0\u0003\u0002\u0002\u0002\u0e0b\u0e0c\u0007", + "U\u0002\u0002\u0e0c\u0e0d\u0007V\u0002\u0002\u0e0d\u0e0e\u0007T\u0002", + "\u0002\u0e0e\u0e0f\u0007K\u0002\u0002\u0e0f\u0e10\u0007R\u0002\u0002", + "\u0e10\u02b2\u0003\u0002\u0002\u0002\u0e11\u0e12\u0007U\u0002\u0002", + "\u0e12\u0e13\u0007[\u0002\u0002\u0e13\u0e14\u0007U\u0002\u0002\u0e14", + "\u0e15\u0007K\u0002\u0002\u0e15\u0e16\u0007F\u0002\u0002\u0e16\u02b4", + "\u0003\u0002\u0002\u0002\u0e17\u0e18\u0007U\u0002\u0002\u0e18\u0e19", + "\u0007[\u0002\u0002\u0e19\u0e1a\u0007U\u0002\u0002\u0e1a\u0e1b\u0007", + "V\u0002\u0002\u0e1b\u0e1c\u0007G\u0002\u0002\u0e1c\u0e1d\u0007O\u0002", + "\u0002\u0e1d\u02b6\u0003\u0002\u0002\u0002\u0e1e\u0e1f\u0007V\u0002", + "\u0002\u0e1f\u0e20\u0007C\u0002\u0002\u0e20\u0e21\u0007D\u0002\u0002", + "\u0e21\u0e22\u0007N\u0002\u0002\u0e22\u0e23\u0007G\u0002\u0002\u0e23", + "\u0e24\u0007U\u0002\u0002\u0e24\u02b8\u0003\u0002\u0002\u0002\u0e25", + "\u0e26\u0007V\u0002\u0002\u0e26\u0e27\u0007C\u0002\u0002\u0e27\u0e28", + "\u0007D\u0002\u0002\u0e28\u0e29\u0007N\u0002\u0002\u0e29\u0e2a\u0007", + "G\u0002\u0002\u0e2a\u0e2b\u0007U\u0002\u0002\u0e2b\u0e2c\u0007R\u0002", + "\u0002\u0e2c\u0e2d\u0007C\u0002\u0002\u0e2d\u0e2e\u0007E\u0002\u0002", + "\u0e2e\u0e2f\u0007G\u0002\u0002\u0e2f\u02ba\u0003\u0002\u0002\u0002", + "\u0e30\u0e31\u0007V\u0002\u0002\u0e31\u0e32\u0007G\u0002\u0002\u0e32", + "\u0e33\u0007O\u0002\u0002\u0e33\u0e34\u0007R\u0002\u0002\u0e34\u02bc", + "\u0003\u0002\u0002\u0002\u0e35\u0e36\u0007V\u0002\u0002\u0e36\u0e37", + "\u0007G\u0002\u0002\u0e37\u0e38\u0007O\u0002\u0002\u0e38\u0e39\u0007", + "R\u0002\u0002\u0e39\u0e3a\u0007N\u0002\u0002\u0e3a\u0e3b\u0007C\u0002", + "\u0002\u0e3b\u0e3c\u0007V\u0002\u0002\u0e3c\u0e3d\u0007G\u0002\u0002", + "\u0e3d\u02be\u0003\u0002\u0002\u0002\u0e3e\u0e3f\u0007V\u0002\u0002", + "\u0e3f\u0e40\u0007G\u0002\u0002\u0e40\u0e41\u0007O\u0002\u0002\u0e41", + "\u0e42\u0007R\u0002\u0002\u0e42\u0e43\u0007Q\u0002\u0002\u0e43\u0e44", + "\u0007T\u0002\u0002\u0e44\u0e45\u0007C\u0002\u0002\u0e45\u0e46\u0007", + "T\u0002\u0002\u0e46\u0e47\u0007[\u0002\u0002\u0e47\u02c0\u0003\u0002", + "\u0002\u0002\u0e48\u0e49\u0007V\u0002\u0002\u0e49\u0e4a\u0007G\u0002", + "\u0002\u0e4a\u0e4b\u0007Z\u0002\u0002\u0e4b\u0e4c\u0007V\u0002\u0002", + "\u0e4c\u02c2\u0003\u0002\u0002\u0002\u0e4d\u0e4e\u0007V\u0002\u0002", + "\u0e4e\u0e4f\u0007T\u0002\u0002\u0e4f\u0e50\u0007C\u0002\u0002\u0e50", + "\u0e51\u0007P\u0002\u0002\u0e51\u0e52\u0007U\u0002\u0002\u0e52\u0e53", + "\u0007C\u0002\u0002\u0e53\u0e54\u0007E\u0002\u0002\u0e54\u0e55\u0007", + "V\u0002\u0002\u0e55\u0e56\u0007K\u0002\u0002\u0e56\u0e57\u0007Q\u0002", + "\u0002\u0e57\u0e58\u0007P\u0002\u0002\u0e58\u02c4\u0003\u0002\u0002", + "\u0002\u0e59\u0e5a\u0007V\u0002\u0002\u0e5a\u0e5b\u0007T\u0002\u0002", + "\u0e5b\u0e5c\u0007K\u0002\u0002\u0e5c\u0e5d\u0007I\u0002\u0002\u0e5d", + "\u0e5e\u0007I\u0002\u0002\u0e5e\u0e5f\u0007G\u0002\u0002\u0e5f\u0e60", + "\u0007T\u0002\u0002\u0e60\u02c6\u0003\u0002\u0002\u0002\u0e61\u0e62", + "\u0007V\u0002\u0002\u0e62\u0e63\u0007T\u0002\u0002\u0e63\u0e64\u0007", + "W\u0002\u0002\u0e64\u0e65\u0007P\u0002\u0002\u0e65\u0e66\u0007E\u0002", + "\u0002\u0e66\u0e67\u0007C\u0002\u0002\u0e67\u0e68\u0007V\u0002\u0002", + "\u0e68\u0e69\u0007G\u0002\u0002\u0e69\u02c8\u0003\u0002\u0002\u0002", + "\u0e6a\u0e6b\u0007V\u0002\u0002\u0e6b\u0e6c\u0007T\u0002\u0002\u0e6c", + "\u0e6d\u0007W\u0002\u0002\u0e6d\u0e6e\u0007U\u0002\u0002\u0e6e\u0e6f", + "\u0007V\u0002\u0002\u0e6f\u0e70\u0007G\u0002\u0002\u0e70\u0e71\u0007", + "F\u0002\u0002\u0e71\u02ca\u0003\u0002\u0002\u0002\u0e72\u0e73\u0007", + "V\u0002\u0002\u0e73\u0e74\u0007[\u0002\u0002\u0e74\u0e75\u0007R\u0002", + "\u0002\u0e75\u0e76\u0007G\u0002\u0002\u0e76\u02cc\u0003\u0002\u0002", + "\u0002\u0e77\u0e78\u0007V\u0002\u0002\u0e78\u0e79\u0007[\u0002\u0002", + "\u0e79\u0e7a\u0007R\u0002\u0002\u0e7a\u0e7b\u0007G\u0002\u0002\u0e7b", + "\u0e7c\u0007U\u0002\u0002\u0e7c\u02ce\u0003\u0002\u0002\u0002\u0e7d", + "\u0e7e\u0007W\u0002\u0002\u0e7e\u0e7f\u0007P\u0002\u0002\u0e7f\u0e80", + "\u0007D\u0002\u0002\u0e80\u0e81\u0007Q\u0002\u0002\u0e81\u0e82\u0007", + "W\u0002\u0002\u0e82\u0e83\u0007P\u0002\u0002\u0e83\u0e84\u0007F\u0002", + "\u0002\u0e84\u0e85\u0007G\u0002\u0002\u0e85\u0e86\u0007F\u0002\u0002", + "\u0e86\u02d0\u0003\u0002\u0002\u0002\u0e87\u0e88\u0007W\u0002\u0002", + "\u0e88\u0e89\u0007P\u0002\u0002\u0e89\u0e8a\u0007E\u0002\u0002\u0e8a", + "\u0e8b\u0007Q\u0002\u0002\u0e8b\u0e8c\u0007O\u0002\u0002\u0e8c\u0e8d", + "\u0007O\u0002\u0002\u0e8d\u0e8e\u0007K\u0002\u0002\u0e8e\u0e8f\u0007", + "V\u0002\u0002\u0e8f\u0e90\u0007V\u0002\u0002\u0e90\u0e91\u0007G\u0002", + "\u0002\u0e91\u0e92\u0007F\u0002\u0002\u0e92\u02d2\u0003\u0002\u0002", + "\u0002\u0e93\u0e94\u0007W\u0002\u0002\u0e94\u0e95\u0007P\u0002\u0002", + "\u0e95\u0e96\u0007G\u0002\u0002\u0e96\u0e97\u0007P\u0002\u0002\u0e97", + "\u0e98\u0007E\u0002\u0002\u0e98\u0e99\u0007T\u0002\u0002\u0e99\u0e9a", + "\u0007[\u0002\u0002\u0e9a\u0e9b\u0007R\u0002\u0002\u0e9b\u0e9c\u0007", + "V\u0002\u0002\u0e9c\u0e9d\u0007G\u0002\u0002\u0e9d\u0e9e\u0007F\u0002", + "\u0002\u0e9e\u02d4\u0003\u0002\u0002\u0002\u0e9f\u0ea0\u0007W\u0002", + "\u0002\u0ea0\u0ea1\u0007P\u0002\u0002\u0ea1\u0ea2\u0007M\u0002\u0002", + "\u0ea2\u0ea3\u0007P\u0002\u0002\u0ea3\u0ea4\u0007Q\u0002\u0002\u0ea4", + "\u0ea5\u0007Y\u0002\u0002\u0ea5\u0ea6\u0007P\u0002\u0002\u0ea6\u02d6", + "\u0003\u0002\u0002\u0002\u0ea7\u0ea8\u0007W\u0002\u0002\u0ea8\u0ea9", + "\u0007P\u0002\u0002\u0ea9\u0eaa\u0007N\u0002\u0002\u0eaa\u0eab\u0007", + "K\u0002\u0002\u0eab\u0eac\u0007U\u0002\u0002\u0eac\u0ead\u0007V\u0002", + "\u0002\u0ead\u0eae\u0007G\u0002\u0002\u0eae\u0eaf\u0007P\u0002\u0002", + "\u0eaf\u02d8\u0003\u0002\u0002\u0002\u0eb0\u0eb1\u0007W\u0002\u0002", + "\u0eb1\u0eb2\u0007P\u0002\u0002\u0eb2\u0eb3\u0007N\u0002\u0002\u0eb3", + "\u0eb4\u0007Q\u0002\u0002\u0eb4\u0eb5\u0007I\u0002\u0002\u0eb5\u0eb6", + "\u0007I\u0002\u0002\u0eb6\u0eb7\u0007G\u0002\u0002\u0eb7\u0eb8\u0007", + "F\u0002\u0002\u0eb8\u02da\u0003\u0002\u0002\u0002\u0eb9\u0eba\u0007", + "W\u0002\u0002\u0eba\u0ebb\u0007P\u0002\u0002\u0ebb\u0ebc\u0007V\u0002", + "\u0002\u0ebc\u0ebd\u0007K\u0002\u0002\u0ebd\u0ebe\u0007N\u0002\u0002", + "\u0ebe\u02dc\u0003\u0002\u0002\u0002\u0ebf\u0ec0\u0007W\u0002\u0002", + "\u0ec0\u0ec1\u0007R\u0002\u0002\u0ec1\u0ec2\u0007F\u0002\u0002\u0ec2", + "\u0ec3\u0007C\u0002\u0002\u0ec3\u0ec4\u0007V\u0002\u0002\u0ec4\u0ec5", + "\u0007G\u0002\u0002\u0ec5\u02de\u0003\u0002\u0002\u0002\u0ec6\u0ec7", + "\u0007X\u0002\u0002\u0ec7\u0ec8\u0007C\u0002\u0002\u0ec8\u0ec9\u0007", + "E\u0002\u0002\u0ec9\u0eca\u0007W\u0002\u0002\u0eca\u0ecb\u0007W\u0002", + "\u0002\u0ecb\u0ecc\u0007O\u0002\u0002\u0ecc\u02e0\u0003\u0002\u0002", + "\u0002\u0ecd\u0ece\u0007X\u0002\u0002\u0ece\u0ecf\u0007C\u0002\u0002", + "\u0ecf\u0ed0\u0007N\u0002\u0002\u0ed0\u0ed1\u0007K\u0002\u0002\u0ed1", + "\u0ed2\u0007F\u0002\u0002\u0ed2\u02e2\u0003\u0002\u0002\u0002\u0ed3", + "\u0ed4\u0007X\u0002\u0002\u0ed4\u0ed5\u0007C\u0002\u0002\u0ed5\u0ed6", + "\u0007N\u0002\u0002\u0ed6\u0ed7\u0007K\u0002\u0002\u0ed7\u0ed8\u0007", + "F\u0002\u0002\u0ed8\u0ed9\u0007C\u0002\u0002\u0ed9\u0eda\u0007V\u0002", + "\u0002\u0eda\u0edb\u0007G\u0002\u0002\u0edb\u02e4\u0003\u0002\u0002", + "\u0002\u0edc\u0edd\u0007X\u0002\u0002\u0edd\u0ede\u0007C\u0002\u0002", + "\u0ede\u0edf\u0007N\u0002\u0002\u0edf\u0ee0\u0007K\u0002\u0002\u0ee0", + "\u0ee1\u0007F\u0002\u0002\u0ee1\u0ee2\u0007C\u0002\u0002\u0ee2\u0ee3", + "\u0007V\u0002\u0002\u0ee3\u0ee4\u0007Q\u0002\u0002\u0ee4\u0ee5\u0007", + "T\u0002\u0002\u0ee5\u02e6\u0003\u0002\u0002\u0002\u0ee6\u0ee7\u0007", + "X\u0002\u0002\u0ee7\u0ee8\u0007C\u0002\u0002\u0ee8\u0ee9\u0007T\u0002", + "\u0002\u0ee9\u0eea\u0007[\u0002\u0002\u0eea\u0eeb\u0007K\u0002\u0002", + "\u0eeb\u0eec\u0007P\u0002\u0002\u0eec\u0eed\u0007I\u0002\u0002\u0eed", + "\u02e8\u0003\u0002\u0002\u0002\u0eee\u0eef\u0007X\u0002\u0002\u0eef", + "\u0ef0\u0007G\u0002\u0002\u0ef0\u0ef1\u0007T\u0002\u0002\u0ef1\u0ef2", + "\u0007U\u0002\u0002\u0ef2\u0ef3\u0007K\u0002\u0002\u0ef3\u0ef4\u0007", + "Q\u0002\u0002\u0ef4\u0ef5\u0007P\u0002\u0002\u0ef5\u02ea\u0003\u0002", + "\u0002\u0002\u0ef6\u0ef7\u0007X\u0002\u0002\u0ef7\u0ef8\u0007K\u0002", + "\u0002\u0ef8\u0ef9\u0007G\u0002\u0002\u0ef9\u0efa\u0007Y\u0002\u0002", + "\u0efa\u02ec\u0003\u0002\u0002\u0002\u0efb\u0efc\u0007X\u0002\u0002", + "\u0efc\u0efd\u0007Q\u0002\u0002\u0efd\u0efe\u0007N\u0002\u0002\u0efe", + "\u0eff\u0007C\u0002\u0002\u0eff\u0f00\u0007V\u0002\u0002\u0f00\u0f01", + "\u0007K\u0002\u0002\u0f01\u0f02\u0007N\u0002\u0002\u0f02\u0f03\u0007", + "G\u0002\u0002\u0f03\u02ee\u0003\u0002\u0002\u0002\u0f04\u0f05\u0007", + "Y\u0002\u0002\u0f05\u0f06\u0007J\u0002\u0002\u0f06\u0f07\u0007K\u0002", + "\u0002\u0f07\u0f08\u0007V\u0002\u0002\u0f08\u0f09\u0007G\u0002\u0002", + "\u0f09\u0f0a\u0007U\u0002\u0002\u0f0a\u0f0b\u0007R\u0002\u0002\u0f0b", + "\u0f0c\u0007C\u0002\u0002\u0f0c\u0f0d\u0007E\u0002\u0002\u0f0d\u0f0e", + "\u0007G\u0002\u0002\u0f0e\u02f0\u0003\u0002\u0002\u0002\u0f0f\u0f10", + "\u0007Y\u0002\u0002\u0f10\u0f11\u0007K\u0002\u0002\u0f11\u0f12\u0007", + "V\u0002\u0002\u0f12\u0f13\u0007J\u0002\u0002\u0f13\u0f14\u0007Q\u0002", + "\u0002\u0f14\u0f15\u0007W\u0002\u0002\u0f15\u0f16\u0007V\u0002\u0002", + "\u0f16\u02f2\u0003\u0002\u0002\u0002\u0f17\u0f18\u0007Y\u0002\u0002", + "\u0f18\u0f19\u0007Q\u0002\u0002\u0f19\u0f1a\u0007T\u0002\u0002\u0f1a", + "\u0f1b\u0007M\u0002\u0002\u0f1b\u02f4\u0003\u0002\u0002\u0002\u0f1c", + "\u0f1d\u0007Y\u0002\u0002\u0f1d\u0f1e\u0007T\u0002\u0002\u0f1e\u0f1f", + "\u0007C\u0002\u0002\u0f1f\u0f20\u0007R\u0002\u0002\u0f20\u0f21\u0007", + "R\u0002\u0002\u0f21\u0f22\u0007G\u0002\u0002\u0f22\u0f23\u0007T\u0002", + "\u0002\u0f23\u02f6\u0003\u0002\u0002\u0002\u0f24\u0f25\u0007Y\u0002", + "\u0002\u0f25\u0f26\u0007T\u0002\u0002\u0f26\u0f27\u0007K\u0002\u0002", + "\u0f27\u0f28\u0007V\u0002\u0002\u0f28\u0f29\u0007G\u0002\u0002\u0f29", + "\u02f8\u0003\u0002\u0002\u0002\u0f2a\u0f2b\u0007Z\u0002\u0002\u0f2b", + "\u0f2c\u0007O\u0002\u0002\u0f2c\u0f2d\u0007N\u0002\u0002\u0f2d\u02fa", + "\u0003\u0002\u0002\u0002\u0f2e\u0f2f\u0007[\u0002\u0002\u0f2f\u0f30", + "\u0007G\u0002\u0002\u0f30\u0f31\u0007C\u0002\u0002\u0f31\u0f32\u0007", + "T\u0002\u0002\u0f32\u02fc\u0003\u0002\u0002\u0002\u0f33\u0f34\u0007", + "[\u0002\u0002\u0f34\u0f35\u0007G\u0002\u0002\u0f35\u0f36\u0007U\u0002", + "\u0002\u0f36\u02fe\u0003\u0002\u0002\u0002\u0f37\u0f38\u0007\\\u0002", + "\u0002\u0f38\u0f39\u0007Q\u0002\u0002\u0f39\u0f3a\u0007P\u0002\u0002", + "\u0f3a\u0f3b\u0007G\u0002\u0002\u0f3b\u0300\u0003\u0002\u0002\u0002", + "\u0f3c\u0f3d\u0007D\u0002\u0002\u0f3d\u0f3e\u0007G\u0002\u0002\u0f3e", + "\u0f3f\u0007V\u0002\u0002\u0f3f\u0f40\u0007Y\u0002\u0002\u0f40\u0f41", + "\u0007G\u0002\u0002\u0f41\u0f42\u0007G\u0002\u0002\u0f42\u0f43\u0007", + "P\u0002\u0002\u0f43\u0302\u0003\u0002\u0002\u0002\u0f44\u0f45\u0007", + "D\u0002\u0002\u0f45\u0f46\u0007K\u0002\u0002\u0f46\u0f47\u0007I\u0002", + "\u0002\u0f47\u0f48\u0007K\u0002\u0002\u0f48\u0f49\u0007P\u0002\u0002", + "\u0f49\u0f4a\u0007V\u0002\u0002\u0f4a\u0304\u0003\u0002\u0002\u0002", + "\u0f4b\u0f4c\u0007D\u0002\u0002\u0f4c\u0f4d\u0007K\u0002\u0002\u0f4d", + "\u0f4e\u0007V\u0002\u0002\u0f4e\u0306\u0003\u0002\u0002\u0002\u0f4f", + "\u0f50\u0007D\u0002\u0002\u0f50\u0f51\u0007Q\u0002\u0002\u0f51\u0f52", + "\u0007Q\u0002\u0002\u0f52\u0f53\u0007N\u0002\u0002\u0f53\u0f54\u0007", + "G\u0002\u0002\u0f54\u0f55\u0007C\u0002\u0002\u0f55\u0f56\u0007P\u0002", + "\u0002\u0f56\u0308\u0003\u0002\u0002\u0002\u0f57\u0f58\u0007E\u0002", + "\u0002\u0f58\u0f59\u0007J\u0002\u0002\u0f59\u0f5a\u0007C\u0002\u0002", + "\u0f5a\u0f5b\u0007T\u0002\u0002\u0f5b\u030a\u0003\u0002\u0002\u0002", + "\u0f5c\u0f5d\u0007E\u0002\u0002\u0f5d\u0f5e\u0007J\u0002\u0002\u0f5e", + "\u0f5f\u0007C\u0002\u0002\u0f5f\u0f60\u0007T\u0002\u0002\u0f60\u0f61", + "\u0007C\u0002\u0002\u0f61\u0f62\u0007E\u0002\u0002\u0f62\u0f63\u0007", + "V\u0002\u0002\u0f63\u0f64\u0007G\u0002\u0002\u0f64\u0f65\u0007T\u0002", + "\u0002\u0f65\u030c\u0003\u0002\u0002\u0002\u0f66\u0f67\u0007E\u0002", + "\u0002\u0f67\u0f68\u0007Q\u0002\u0002\u0f68\u0f69\u0007C\u0002\u0002", + "\u0f69\u0f6a\u0007N\u0002\u0002\u0f6a\u0f6b\u0007G\u0002\u0002\u0f6b", + "\u0f6c\u0007U\u0002\u0002\u0f6c\u0f6d\u0007E\u0002\u0002\u0f6d\u0f6e", + "\u0007G\u0002\u0002\u0f6e\u030e\u0003\u0002\u0002\u0002\u0f6f\u0f70", + "\u0007F\u0002\u0002\u0f70\u0f71\u0007G\u0002\u0002\u0f71\u0f72\u0007", + "E\u0002\u0002\u0f72\u0310\u0003\u0002\u0002\u0002\u0f73\u0f74\u0007", + "F\u0002\u0002\u0f74\u0f75\u0007G\u0002\u0002\u0f75\u0f76\u0007E\u0002", + "\u0002\u0f76\u0f77\u0007K\u0002\u0002\u0f77\u0f78\u0007O\u0002\u0002", + "\u0f78\u0f79\u0007C\u0002\u0002\u0f79\u0f7a\u0007N\u0002\u0002\u0f7a", + "\u0312\u0003\u0002\u0002\u0002\u0f7b\u0f7c\u0007G\u0002\u0002\u0f7c", + "\u0f7d\u0007Z\u0002\u0002\u0f7d\u0f7e\u0007K\u0002\u0002\u0f7e\u0f7f", + "\u0007U\u0002\u0002\u0f7f\u0f80\u0007V\u0002\u0002\u0f80\u0f81\u0007", + "U\u0002\u0002\u0f81\u0314\u0003\u0002\u0002\u0002\u0f82\u0f83\u0007", + "G\u0002\u0002\u0f83\u0f84\u0007Z\u0002\u0002\u0f84\u0f85\u0007V\u0002", + "\u0002\u0f85\u0f86\u0007T\u0002\u0002\u0f86\u0f87\u0007C\u0002\u0002", + "\u0f87\u0f88\u0007E\u0002\u0002\u0f88\u0f89\u0007V\u0002\u0002\u0f89", + "\u0316\u0003\u0002\u0002\u0002\u0f8a\u0f8b\u0007H\u0002\u0002\u0f8b", + "\u0f8c\u0007N\u0002\u0002\u0f8c\u0f8d\u0007Q\u0002\u0002\u0f8d\u0f8e", + "\u0007C\u0002\u0002\u0f8e\u0f8f\u0007V\u0002\u0002\u0f8f\u0318\u0003", + "\u0002\u0002\u0002\u0f90\u0f91\u0007I\u0002\u0002\u0f91\u0f92\u0007", + "T\u0002\u0002\u0f92\u0f93\u0007G\u0002\u0002\u0f93\u0f94\u0007C\u0002", + "\u0002\u0f94\u0f95\u0007V\u0002\u0002\u0f95\u0f96\u0007G\u0002\u0002", + "\u0f96\u0f97\u0007U\u0002\u0002\u0f97\u0f98\u0007V\u0002\u0002\u0f98", + "\u031a\u0003\u0002\u0002\u0002\u0f99\u0f9a\u0007K\u0002\u0002\u0f9a", + "\u0f9b\u0007P\u0002\u0002\u0f9b\u0f9c\u0007Q\u0002\u0002\u0f9c\u0f9d", + "\u0007W\u0002\u0002\u0f9d\u0f9e\u0007V\u0002\u0002\u0f9e\u031c\u0003", + "\u0002\u0002\u0002\u0f9f\u0fa0\u0007K\u0002\u0002\u0fa0\u0fa1\u0007", + "P\u0002\u0002\u0fa1\u0fa2\u0007V\u0002\u0002\u0fa2\u031e\u0003\u0002", + "\u0002\u0002\u0fa3\u0fa4\u0007K\u0002\u0002\u0fa4\u0fa5\u0007P\u0002", + "\u0002\u0fa5\u0fa6\u0007V\u0002\u0002\u0fa6\u0fa7\u0007G\u0002\u0002", + "\u0fa7\u0fa8\u0007I\u0002\u0002\u0fa8\u0fa9\u0007G\u0002\u0002\u0fa9", + "\u0faa\u0007T\u0002\u0002\u0faa\u0320\u0003\u0002\u0002\u0002\u0fab", + "\u0fac\u0007K\u0002\u0002\u0fac\u0fad\u0007P\u0002\u0002\u0fad\u0fae", + "\u0007V\u0002\u0002\u0fae\u0faf\u0007G\u0002\u0002\u0faf\u0fb0\u0007", + "T\u0002\u0002\u0fb0\u0fb1\u0007X\u0002\u0002\u0fb1\u0fb2\u0007C\u0002", + "\u0002\u0fb2\u0fb3\u0007N\u0002\u0002\u0fb3\u0322\u0003\u0002\u0002", + "\u0002\u0fb4\u0fb5\u0007N\u0002\u0002\u0fb5\u0fb6\u0007G\u0002\u0002", + "\u0fb6\u0fb7\u0007C\u0002\u0002\u0fb7\u0fb8\u0007U\u0002\u0002\u0fb8", + "\u0fb9\u0007V\u0002\u0002\u0fb9\u0324\u0003\u0002\u0002\u0002\u0fba", + "\u0fbb\u0007P\u0002\u0002\u0fbb\u0fbc\u0007C\u0002\u0002\u0fbc\u0fbd", + "\u0007V\u0002\u0002\u0fbd\u0fbe\u0007K\u0002\u0002\u0fbe\u0fbf\u0007", + "Q\u0002\u0002\u0fbf\u0fc0\u0007P\u0002\u0002\u0fc0\u0fc1\u0007C\u0002", + "\u0002\u0fc1\u0fc2\u0007N\u0002\u0002\u0fc2\u0326\u0003\u0002\u0002", + "\u0002\u0fc3\u0fc4\u0007P\u0002\u0002\u0fc4\u0fc5\u0007E\u0002\u0002", + "\u0fc5\u0fc6\u0007J\u0002\u0002\u0fc6\u0fc7\u0007C\u0002\u0002\u0fc7", + "\u0fc8\u0007T\u0002\u0002\u0fc8\u0328\u0003\u0002\u0002\u0002\u0fc9", + "\u0fca\u0007P\u0002\u0002\u0fca\u0fcb\u0007Q\u0002\u0002\u0fcb\u0fcc", + "\u0007P\u0002\u0002\u0fcc\u0fcd\u0007G\u0002\u0002\u0fcd\u032a\u0003", + "\u0002\u0002\u0002\u0fce\u0fcf\u0007P\u0002\u0002\u0fcf\u0fd0\u0007", + "W\u0002\u0002\u0fd0\u0fd1\u0007N\u0002\u0002\u0fd1\u0fd2\u0007N\u0002", + "\u0002\u0fd2\u0fd3\u0007K\u0002\u0002\u0fd3\u0fd4\u0007H\u0002\u0002", + "\u0fd4\u032c\u0003\u0002\u0002\u0002\u0fd5\u0fd6\u0007P\u0002\u0002", + "\u0fd6\u0fd7\u0007W\u0002\u0002\u0fd7\u0fd8\u0007O\u0002\u0002\u0fd8", + "\u0fd9\u0007G\u0002\u0002\u0fd9\u0fda\u0007T\u0002\u0002\u0fda\u0fdb", + "\u0007K\u0002\u0002\u0fdb\u0fdc\u0007E\u0002\u0002\u0fdc\u032e\u0003", + "\u0002\u0002\u0002\u0fdd\u0fde\u0007Q\u0002\u0002\u0fde\u0fdf\u0007", + "X\u0002\u0002\u0fdf\u0fe0\u0007G\u0002\u0002\u0fe0\u0fe1\u0007T\u0002", + "\u0002\u0fe1\u0fe2\u0007N\u0002\u0002\u0fe2\u0fe3\u0007C\u0002\u0002", + "\u0fe3\u0fe4\u0007[\u0002\u0002\u0fe4\u0330\u0003\u0002\u0002\u0002", + "\u0fe5\u0fe6\u0007R\u0002\u0002\u0fe6\u0fe7\u0007Q\u0002\u0002\u0fe7", + "\u0fe8\u0007U\u0002\u0002\u0fe8\u0fe9\u0007K\u0002\u0002\u0fe9\u0fea", + "\u0007V\u0002\u0002\u0fea\u0feb\u0007K\u0002\u0002\u0feb\u0fec\u0007", + "Q\u0002\u0002\u0fec\u0fed\u0007P\u0002\u0002\u0fed\u0332\u0003\u0002", + "\u0002\u0002\u0fee\u0fef\u0007R\u0002\u0002\u0fef\u0ff0\u0007T\u0002", + "\u0002\u0ff0\u0ff1\u0007G\u0002\u0002\u0ff1\u0ff2\u0007E\u0002\u0002", + "\u0ff2\u0ff3\u0007K\u0002\u0002\u0ff3\u0ff4\u0007U\u0002\u0002\u0ff4", + "\u0ff5\u0007K\u0002\u0002\u0ff5\u0ff6\u0007Q\u0002\u0002\u0ff6\u0ff7", + "\u0007P\u0002\u0002\u0ff7\u0334\u0003\u0002\u0002\u0002\u0ff8\u0ff9", + "\u0007T\u0002\u0002\u0ff9\u0ffa\u0007G\u0002\u0002\u0ffa\u0ffb\u0007", + "C\u0002\u0002\u0ffb\u0ffc\u0007N\u0002\u0002\u0ffc\u0336\u0003\u0002", + "\u0002\u0002\u0ffd\u0ffe\u0007T\u0002\u0002\u0ffe\u0fff\u0007Q\u0002", + "\u0002\u0fff\u1000\u0007Y\u0002\u0002\u1000\u0338\u0003\u0002\u0002", + "\u0002\u1001\u1002\u0007U\u0002\u0002\u1002\u1003\u0007G\u0002\u0002", + "\u1003\u1004\u0007V\u0002\u0002\u1004\u1005\u0007Q\u0002\u0002\u1005", + "\u1006\u0007H\u0002\u0002\u1006\u033a\u0003\u0002\u0002\u0002\u1007", + "\u1008\u0007U\u0002\u0002\u1008\u1009\u0007O\u0002\u0002\u1009\u100a", + "\u0007C\u0002\u0002\u100a\u100b\u0007N\u0002\u0002\u100b\u100c\u0007", + "N\u0002\u0002\u100c\u100d\u0007K\u0002\u0002\u100d\u100e\u0007P\u0002", + "\u0002\u100e\u100f\u0007V\u0002\u0002\u100f\u033c\u0003\u0002\u0002", + "\u0002\u1010\u1011\u0007U\u0002\u0002\u1011\u1012\u0007W\u0002\u0002", + "\u1012\u1013\u0007D\u0002\u0002\u1013\u1014\u0007U\u0002\u0002\u1014", + "\u1015\u0007V\u0002\u0002\u1015\u1016\u0007T\u0002\u0002\u1016\u1017", + "\u0007K\u0002\u0002\u1017\u1018\u0007P\u0002\u0002\u1018\u1019\u0007", + "I\u0002\u0002\u1019\u033e\u0003\u0002\u0002\u0002\u101a\u101b\u0007", + "V\u0002\u0002\u101b\u101c\u0007K\u0002\u0002\u101c\u101d\u0007O\u0002", + "\u0002\u101d\u101e\u0007G\u0002\u0002\u101e\u0340\u0003\u0002\u0002", + "\u0002\u101f\u1020\u0007V\u0002\u0002\u1020\u1021\u0007K\u0002\u0002", + "\u1021\u1022\u0007O\u0002\u0002\u1022\u1023\u0007G\u0002\u0002\u1023", + "\u1024\u0007U\u0002\u0002\u1024\u1025\u0007V\u0002\u0002\u1025\u1026", + "\u0007C\u0002\u0002\u1026\u1027\u0007O\u0002\u0002\u1027\u1028\u0007", + "R\u0002\u0002\u1028\u0342\u0003\u0002\u0002\u0002\u1029\u102a\u0007", + "V\u0002\u0002\u102a\u102b\u0007T\u0002\u0002\u102b\u102c\u0007G\u0002", + "\u0002\u102c\u102d\u0007C\u0002\u0002\u102d\u102e\u0007V\u0002\u0002", + "\u102e\u0344\u0003\u0002\u0002\u0002\u102f\u1030\u0007V\u0002\u0002", + "\u1030\u1031\u0007T\u0002\u0002\u1031\u1032\u0007K\u0002\u0002\u1032", + "\u1033\u0007O\u0002\u0002\u1033\u0346\u0003\u0002\u0002\u0002\u1034", + "\u1035\u0007X\u0002\u0002\u1035\u1036\u0007C\u0002\u0002\u1036\u1037", + "\u0007N\u0002\u0002\u1037\u1038\u0007W\u0002\u0002\u1038\u1039\u0007", + "G\u0002\u0002\u1039\u103a\u0007U\u0002\u0002\u103a\u0348\u0003\u0002", + "\u0002\u0002\u103b\u103c\u0007X\u0002\u0002\u103c\u103d\u0007C\u0002", + "\u0002\u103d\u103e\u0007T\u0002\u0002\u103e\u103f\u0007E\u0002\u0002", + "\u103f\u1040\u0007J\u0002\u0002\u1040\u1041\u0007C\u0002\u0002\u1041", + "\u1042\u0007T\u0002\u0002\u1042\u034a\u0003\u0002\u0002\u0002\u1043", + "\u1044\u0007Z\u0002\u0002\u1044\u1045\u0007O\u0002\u0002\u1045\u1046", + "\u0007N\u0002\u0002\u1046\u1047\u0007C\u0002\u0002\u1047\u1048\u0007", + "V\u0002\u0002\u1048\u1049\u0007V\u0002\u0002\u1049\u104a\u0007T\u0002", + "\u0002\u104a\u104b\u0007K\u0002\u0002\u104b\u104c\u0007D\u0002\u0002", + "\u104c\u104d\u0007W\u0002\u0002\u104d\u104e\u0007V\u0002\u0002\u104e", + "\u104f\u0007G\u0002\u0002\u104f\u1050\u0007U\u0002\u0002\u1050\u034c", + "\u0003\u0002\u0002\u0002\u1051\u1052\u0007Z\u0002\u0002\u1052\u1053", + "\u0007O\u0002\u0002\u1053\u1054\u0007N\u0002\u0002\u1054\u1055\u0007", + "E\u0002\u0002\u1055\u1056\u0007Q\u0002\u0002\u1056\u1057\u0007P\u0002", + "\u0002\u1057\u1058\u0007E\u0002\u0002\u1058\u1059\u0007C\u0002\u0002", + "\u1059\u105a\u0007V\u0002\u0002\u105a\u034e\u0003\u0002\u0002\u0002", + "\u105b\u105c\u0007Z\u0002\u0002\u105c\u105d\u0007O\u0002\u0002\u105d", + "\u105e\u0007N\u0002\u0002\u105e\u105f\u0007G\u0002\u0002\u105f\u1060", + "\u0007N\u0002\u0002\u1060\u1061\u0007G\u0002\u0002\u1061\u1062\u0007", + "O\u0002\u0002\u1062\u1063\u0007G\u0002\u0002\u1063\u1064\u0007P\u0002", + "\u0002\u1064\u1065\u0007V\u0002\u0002\u1065\u0350\u0003\u0002\u0002", + "\u0002\u1066\u1067\u0007Z\u0002\u0002\u1067\u1068\u0007O\u0002\u0002", + "\u1068\u1069\u0007N\u0002\u0002\u1069\u106a\u0007G\u0002\u0002\u106a", + "\u106b\u0007Z\u0002\u0002\u106b\u106c\u0007K\u0002\u0002\u106c\u106d", + "\u0007U\u0002\u0002\u106d\u106e\u0007V\u0002\u0002\u106e\u106f\u0007", + "U\u0002\u0002\u106f\u0352\u0003\u0002\u0002\u0002\u1070\u1071\u0007", + "Z\u0002\u0002\u1071\u1072\u0007O\u0002\u0002\u1072\u1073\u0007N\u0002", + "\u0002\u1073\u1074\u0007H\u0002\u0002\u1074\u1075\u0007Q\u0002\u0002", + "\u1075\u1076\u0007T\u0002\u0002\u1076\u1077\u0007G\u0002\u0002\u1077", + "\u1078\u0007U\u0002\u0002\u1078\u1079\u0007V\u0002\u0002\u1079\u0354", + "\u0003\u0002\u0002\u0002\u107a\u107b\u0007Z\u0002\u0002\u107b\u107c", + "\u0007O\u0002\u0002\u107c\u107d\u0007N\u0002\u0002\u107d\u107e\u0007", + "R\u0002\u0002\u107e\u107f\u0007C\u0002\u0002\u107f\u1080\u0007T\u0002", + "\u0002\u1080\u1081\u0007U\u0002\u0002\u1081\u1082\u0007G\u0002\u0002", + "\u1082\u0356\u0003\u0002\u0002\u0002\u1083\u1084\u0007Z\u0002\u0002", + "\u1084\u1085\u0007O\u0002\u0002\u1085\u1086\u0007N\u0002\u0002\u1086", + "\u1087\u0007R\u0002\u0002\u1087\u1088\u0007K\u0002\u0002\u1088\u0358", + "\u0003\u0002\u0002\u0002\u1089\u108a\u0007Z\u0002\u0002\u108a\u108b", + "\u0007O\u0002\u0002\u108b\u108c\u0007N\u0002\u0002\u108c\u108d\u0007", + "T\u0002\u0002\u108d\u108e\u0007Q\u0002\u0002\u108e\u108f\u0007Q\u0002", + "\u0002\u108f\u1090\u0007V\u0002\u0002\u1090\u035a\u0003\u0002\u0002", + "\u0002\u1091\u1092\u0007Z\u0002\u0002\u1092\u1093\u0007O\u0002\u0002", + "\u1093\u1094\u0007N\u0002\u0002\u1094\u1095\u0007U\u0002\u0002\u1095", + "\u1096\u0007G\u0002\u0002\u1096\u1097\u0007T\u0002\u0002\u1097\u1098", + "\u0007K\u0002\u0002\u1098\u1099\u0007C\u0002\u0002\u1099\u109a\u0007", + "N\u0002\u0002\u109a\u109b\u0007K\u0002\u0002\u109b\u109c\u0007\\\u0002", + "\u0002\u109c\u109d\u0007G\u0002\u0002\u109d\u035c\u0003\u0002\u0002", + "\u0002\u109e\u109f\u0007E\u0002\u0002\u109f\u10a0\u0007C\u0002\u0002", + "\u10a0\u10a1\u0007N\u0002\u0002\u10a1\u10a2\u0007N\u0002\u0002\u10a2", + "\u035e\u0003\u0002\u0002\u0002\u10a3\u10a4\u0007E\u0002\u0002\u10a4", + "\u10a5\u0007W\u0002\u0002\u10a5\u10a6\u0007T\u0002\u0002\u10a6\u10a7", + "\u0007T\u0002\u0002\u10a7\u10a8\u0007G\u0002\u0002\u10a8\u10a9\u0007", + "P\u0002\u0002\u10a9\u10aa\u0007V\u0002\u0002\u10aa\u0360\u0003\u0002", + "\u0002\u0002\u10ab\u10ac\u0007C\u0002\u0002\u10ac\u10ad\u0007V\u0002", + "\u0002\u10ad\u10ae\u0007V\u0002\u0002\u10ae\u10af\u0007C\u0002\u0002", + "\u10af\u10b0\u0007E\u0002\u0002\u10b0\u10b1\u0007J\u0002\u0002\u10b1", + "\u0362\u0003\u0002\u0002\u0002\u10b2\u10b3\u0007F\u0002\u0002\u10b3", + "\u10b4\u0007G\u0002\u0002\u10b4\u10b5\u0007V\u0002\u0002\u10b5\u10b6", + "\u0007C\u0002\u0002\u10b6\u10b7\u0007E\u0002\u0002\u10b7\u10b8\u0007", + "J\u0002\u0002\u10b8\u0364\u0003\u0002\u0002\u0002\u10b9\u10ba\u0007", + "G\u0002\u0002\u10ba\u10bb\u0007Z\u0002\u0002\u10bb\u10bc\u0007R\u0002", + "\u0002\u10bc\u10bd\u0007T\u0002\u0002\u10bd\u10be\u0007G\u0002\u0002", + "\u10be\u10bf\u0007U\u0002\u0002\u10bf\u10c0\u0007U\u0002\u0002\u10c0", + "\u10c1\u0007K\u0002\u0002\u10c1\u10c2\u0007Q\u0002\u0002\u10c2\u10c3", + "\u0007P\u0002\u0002\u10c3\u0366\u0003\u0002\u0002\u0002\u10c4\u10c5", + "\u0007I\u0002\u0002\u10c5\u10c6\u0007G\u0002\u0002\u10c6\u10c7\u0007", + "P\u0002\u0002\u10c7\u10c8\u0007G\u0002\u0002\u10c8\u10c9\u0007T\u0002", + "\u0002\u10c9\u10ca\u0007C\u0002\u0002\u10ca\u10cb\u0007V\u0002\u0002", + "\u10cb\u10cc\u0007G\u0002\u0002\u10cc\u10cd\u0007F\u0002\u0002\u10cd", + "\u0368\u0003\u0002\u0002\u0002\u10ce\u10cf\u0007N\u0002\u0002\u10cf", + "\u10d0\u0007Q\u0002\u0002\u10d0\u10d1\u0007I\u0002\u0002\u10d1\u10d2", + "\u0007I\u0002\u0002\u10d2\u10d3\u0007G\u0002\u0002\u10d3\u10d4\u0007", + "F\u0002\u0002\u10d4\u036a\u0003\u0002\u0002\u0002\u10d5\u10d6\u0007", + "U\u0002\u0002\u10d6\u10d7\u0007V\u0002\u0002\u10d7\u10d8\u0007Q\u0002", + "\u0002\u10d8\u10d9\u0007T\u0002\u0002\u10d9\u10da\u0007G\u0002\u0002", + "\u10da\u10db\u0007F\u0002\u0002\u10db\u036c\u0003\u0002\u0002\u0002", + "\u10dc\u10dd\u0007K\u0002\u0002\u10dd\u10de\u0007P\u0002\u0002\u10de", + "\u10df\u0007E\u0002\u0002\u10df\u10e0\u0007N\u0002\u0002\u10e0\u10e1", + "\u0007W\u0002\u0002\u10e1\u10e2\u0007F\u0002\u0002\u10e2\u10e3\u0007", + "G\u0002\u0002\u10e3\u036e\u0003\u0002\u0002\u0002\u10e4\u10e5\u0007", + "T\u0002\u0002\u10e5\u10e6\u0007Q\u0002\u0002\u10e6\u10e7\u0007W\u0002", + "\u0002\u10e7\u10e8\u0007V\u0002\u0002\u10e8\u10e9\u0007K\u0002\u0002", + "\u10e9\u10ea\u0007P\u0002\u0002\u10ea\u10eb\u0007G\u0002\u0002\u10eb", + "\u0370\u0003\u0002\u0002\u0002\u10ec\u10ed\u0007V\u0002\u0002\u10ed", + "\u10ee\u0007T\u0002\u0002\u10ee\u10ef\u0007C\u0002\u0002\u10ef\u10f0", + "\u0007P\u0002\u0002\u10f0\u10f1\u0007U\u0002\u0002\u10f1\u10f2\u0007", + "H\u0002\u0002\u10f2\u10f3\u0007Q\u0002\u0002\u10f3\u10f4\u0007T\u0002", + "\u0002\u10f4\u10f5\u0007O\u0002\u0002\u10f5\u0372\u0003\u0002\u0002", + "\u0002\u10f6\u10f7\u0007K\u0002\u0002\u10f7\u10f8\u0007O\u0002\u0002", + "\u10f8\u10f9\u0007R\u0002\u0002\u10f9\u10fa\u0007Q\u0002\u0002\u10fa", + "\u10fb\u0007T\u0002\u0002\u10fb\u10fc\u0007V\u0002\u0002\u10fc\u0374", + "\u0003\u0002\u0002\u0002\u10fd\u10fe\u0007R\u0002\u0002\u10fe\u10ff", + "\u0007Q\u0002\u0002\u10ff\u1100\u0007N\u0002\u0002\u1100\u1101\u0007", + "K\u0002\u0002\u1101\u1102\u0007E\u0002\u0002\u1102\u1103\u0007[\u0002", + "\u0002\u1103\u0376\u0003\u0002\u0002\u0002\u1104\u1105\u0007O\u0002", + "\u0002\u1105\u1106\u0007G\u0002\u0002\u1106\u1107\u0007V\u0002\u0002", + "\u1107\u1108\u0007J\u0002\u0002\u1108\u1109\u0007Q\u0002\u0002\u1109", + "\u110a\u0007F\u0002\u0002\u110a\u0378\u0003\u0002\u0002\u0002\u110b", + "\u110c\u0007T\u0002\u0002\u110c\u110d\u0007G\u0002\u0002\u110d\u110e", + "\u0007H\u0002\u0002\u110e\u110f\u0007G\u0002\u0002\u110f\u1110\u0007", + "T\u0002\u0002\u1110\u1111\u0007G\u0002\u0002\u1111\u1112\u0007P\u0002", + "\u0002\u1112\u1113\u0007E\u0002\u0002\u1113\u1114\u0007K\u0002\u0002", + "\u1114\u1115\u0007P\u0002\u0002\u1115\u1116\u0007I\u0002\u0002\u1116", + "\u037a\u0003\u0002\u0002\u0002\u1117\u1118\u0007P\u0002\u0002\u1118", + "\u1119\u0007G\u0002\u0002\u1119\u111a\u0007Y\u0002\u0002\u111a\u037c", + "\u0003\u0002\u0002\u0002\u111b\u111c\u0007Q\u0002\u0002\u111c\u111d", + "\u0007N\u0002\u0002\u111d\u111e\u0007F\u0002\u0002\u111e\u037e\u0003", + "\u0002\u0002\u0002\u111f\u1120\u0007X\u0002\u0002\u1120\u1121\u0007", + "C\u0002\u0002\u1121\u1122\u0007N\u0002\u0002\u1122\u1123\u0007W\u0002", + "\u0002\u1123\u1124\u0007G\u0002\u0002\u1124\u0380\u0003\u0002\u0002", + "\u0002\u1125\u1126\u0007U\u0002\u0002\u1126\u1127\u0007W\u0002\u0002", + "\u1127\u1128\u0007D\u0002\u0002\u1128\u1129\u0007U\u0002\u0002\u1129", + "\u112a\u0007E\u0002\u0002\u112a\u112b\u0007T\u0002\u0002\u112b\u112c", + "\u0007K\u0002\u0002\u112c\u112d\u0007R\u0002\u0002\u112d\u112e\u0007", + "V\u0002\u0002\u112e\u112f\u0007K\u0002\u0002\u112f\u1130\u0007Q\u0002", + "\u0002\u1130\u1131\u0007P\u0002\u0002\u1131\u0382\u0003\u0002\u0002", + "\u0002\u1132\u1133\u0007R\u0002\u0002\u1133\u1134\u0007W\u0002\u0002", + "\u1134\u1135\u0007D\u0002\u0002\u1135\u1136\u0007N\u0002\u0002\u1136", + "\u1137\u0007K\u0002\u0002\u1137\u1138\u0007E\u0002\u0002\u1138\u1139", + "\u0007C\u0002\u0002\u1139\u113a\u0007V\u0002\u0002\u113a\u113b\u0007", + "K\u0002\u0002\u113b\u113c\u0007Q\u0002\u0002\u113c\u113d\u0007P\u0002", + "\u0002\u113d\u0384\u0003\u0002\u0002\u0002\u113e\u113f\u0007Q\u0002", + "\u0002\u113f\u1140\u0007W\u0002\u0002\u1140\u1141\u0007V\u0002\u0002", + "\u1141\u0386\u0003\u0002\u0002\u0002\u1142\u1143\u0007G\u0002\u0002", + "\u1143\u1144\u0007P\u0002\u0002\u1144\u1145\u0007F\u0002\u0002\u1145", + "\u0388\u0003\u0002\u0002\u0002\u1146\u1147\u0007T\u0002\u0002\u1147", + "\u1148\u0007Q\u0002\u0002\u1148\u1149\u0007W\u0002\u0002\u1149\u114a", + "\u0007V\u0002\u0002\u114a\u114b\u0007K\u0002\u0002\u114b\u114c\u0007", + "P\u0002\u0002\u114c\u114d\u0007G\u0002\u0002\u114d\u114e\u0007U\u0002", + "\u0002\u114e\u038a\u0003\u0002\u0002\u0002\u114f\u1150\u0007U\u0002", + "\u0002\u1150\u1151\u0007E\u0002\u0002\u1151\u1152\u0007J\u0002\u0002", + "\u1152\u1153\u0007G\u0002\u0002\u1153\u1154\u0007O\u0002\u0002\u1154", + "\u1155\u0007C\u0002\u0002\u1155\u1156\u0007U\u0002\u0002\u1156\u038c", + "\u0003\u0002\u0002\u0002\u1157\u1158\u0007R\u0002\u0002\u1158\u1159", + "\u0007T\u0002\u0002\u1159\u115a\u0007Q\u0002\u0002\u115a\u115b\u0007", + "E\u0002\u0002\u115b\u115c\u0007G\u0002\u0002\u115c\u115d\u0007F\u0002", + "\u0002\u115d\u115e\u0007W\u0002\u0002\u115e\u115f\u0007T\u0002\u0002", + "\u115f\u1160\u0007G\u0002\u0002\u1160\u1161\u0007U\u0002\u0002\u1161", + "\u038e\u0003\u0002\u0002\u0002\u1162\u1163\u0007K\u0002\u0002\u1163", + "\u1164\u0007P\u0002\u0002\u1164\u1165\u0007R\u0002\u0002\u1165\u1166", + "\u0007W\u0002\u0002\u1166\u1167\u0007V\u0002\u0002\u1167\u0390\u0003", + "\u0002\u0002\u0002\u1168\u1169\u0007U\u0002\u0002\u1169\u116a\u0007", + "W\u0002\u0002\u116a\u116b\u0007R\u0002\u0002\u116b\u116c\u0007R\u0002", + "\u0002\u116c\u116d\u0007Q\u0002\u0002\u116d\u116e\u0007T\u0002\u0002", + "\u116e\u116f\u0007V\u0002\u0002\u116f\u0392\u0003\u0002\u0002\u0002", + "\u1170\u1171\u0007R\u0002\u0002\u1171\u1172\u0007C\u0002\u0002\u1172", + "\u1173\u0007T\u0002\u0002\u1173\u1174\u0007C\u0002\u0002\u1174\u1175", + "\u0007N\u0002\u0002\u1175\u1176\u0007N\u0002\u0002\u1176\u1177\u0007", + "G\u0002\u0002\u1177\u1178\u0007N\u0002\u0002\u1178\u0394\u0003\u0002", + "\u0002\u0002\u1179\u117a\u0007U\u0002\u0002\u117a\u117b\u0007S\u0002", + "\u0002\u117b\u117c\u0007N\u0002\u0002\u117c\u0396\u0003\u0002\u0002", + "\u0002\u117d\u117e\u0007F\u0002\u0002\u117e\u117f\u0007G\u0002\u0002", + "\u117f\u1180\u0007R\u0002\u0002\u1180\u1181\u0007G\u0002\u0002\u1181", + "\u1182\u0007P\u0002\u0002\u1182\u1183\u0007F\u0002\u0002\u1183\u1184", + "\u0007U\u0002\u0002\u1184\u0398\u0003\u0002\u0002\u0002\u1185\u1186", + "\u0007Q\u0002\u0002\u1186\u1187\u0007X\u0002\u0002\u1187\u1188\u0007", + "G\u0002\u0002\u1188\u1189\u0007T\u0002\u0002\u1189\u118a\u0007T\u0002", + "\u0002\u118a\u118b\u0007K\u0002\u0002\u118b\u118c\u0007F\u0002\u0002", + "\u118c\u118d\u0007K\u0002\u0002\u118d\u118e\u0007P\u0002\u0002\u118e", + "\u118f\u0007I\u0002\u0002\u118f\u039a\u0003\u0002\u0002\u0002\u1190", + "\u1191\u0007E\u0002\u0002\u1191\u1192\u0007Q\u0002\u0002\u1192\u1193", + "\u0007P\u0002\u0002\u1193\u1194\u0007H\u0002\u0002\u1194\u1195\u0007", + "N\u0002\u0002\u1195\u1196\u0007K\u0002\u0002\u1196\u1197\u0007E\u0002", + "\u0002\u1197\u1198\u0007V\u0002\u0002\u1198\u039c\u0003\u0002\u0002", + "\u0002\u1199\u119a\u0007U\u0002\u0002\u119a\u119b\u0007M\u0002\u0002", + "\u119b\u119c\u0007K\u0002\u0002\u119c\u119d\u0007R\u0002\u0002\u119d", + "\u039e\u0003\u0002\u0002\u0002\u119e\u119f\u0007N\u0002\u0002\u119f", + "\u11a0\u0007Q\u0002\u0002\u11a0\u11a1\u0007E\u0002\u0002\u11a1\u11a2", + "\u0007M\u0002\u0002\u11a2\u11a3\u0007G\u0002\u0002\u11a3\u11a4\u0007", + "F\u0002\u0002\u11a4\u03a0\u0003\u0002\u0002\u0002\u11a5\u11a6\u0007", + "V\u0002\u0002\u11a6\u11a7\u0007K\u0002\u0002\u11a7\u11a8\u0007G\u0002", + "\u0002\u11a8\u11a9\u0007U\u0002\u0002\u11a9\u03a2\u0003\u0002\u0002", + "\u0002\u11aa\u11ab\u0007T\u0002\u0002\u11ab\u11ac\u0007Q\u0002\u0002", + "\u11ac\u11ad\u0007N\u0002\u0002\u11ad\u11ae\u0007N\u0002\u0002\u11ae", + "\u11af\u0007W\u0002\u0002\u11af\u11b0\u0007R\u0002\u0002\u11b0\u03a4", + "\u0003\u0002\u0002\u0002\u11b1\u11b2\u0007E\u0002\u0002\u11b2\u11b3", + "\u0007W\u0002\u0002\u11b3\u11b4\u0007D\u0002\u0002\u11b4\u11b5\u0007", + "G\u0002\u0002\u11b5\u03a6\u0003\u0002\u0002\u0002\u11b6\u11b7\u0007", + "I\u0002\u0002\u11b7\u11b8\u0007T\u0002\u0002\u11b8\u11b9\u0007Q\u0002", + "\u0002\u11b9\u11ba\u0007W\u0002\u0002\u11ba\u11bb\u0007R\u0002\u0002", + "\u11bb\u11bc\u0007K\u0002\u0002\u11bc\u11bd\u0007P\u0002\u0002\u11bd", + "\u11be\u0007I\u0002\u0002\u11be\u03a8\u0003\u0002\u0002\u0002\u11bf", + "\u11c0\u0007U\u0002\u0002\u11c0\u11c1\u0007G\u0002\u0002\u11c1\u11c2", + "\u0007V\u0002\u0002\u11c2\u11c3\u0007U\u0002\u0002\u11c3\u03aa\u0003", + "\u0002\u0002\u0002\u11c4\u11c5\u0007V\u0002\u0002\u11c5\u11c6\u0007", + "C\u0002\u0002\u11c6\u11c7\u0007D\u0002\u0002\u11c7\u11c8\u0007N\u0002", + "\u0002\u11c8\u11c9\u0007G\u0002\u0002\u11c9\u11ca\u0007U\u0002\u0002", + "\u11ca\u11cb\u0007C\u0002\u0002\u11cb\u11cc\u0007O\u0002\u0002\u11cc", + "\u11cd\u0007R\u0002\u0002\u11cd\u11ce\u0007N\u0002\u0002\u11ce\u11cf", + "\u0007G\u0002\u0002\u11cf\u03ac\u0003\u0002\u0002\u0002\u11d0\u11d1", + "\u0007Q\u0002\u0002\u11d1\u11d2\u0007T\u0002\u0002\u11d2\u11d3\u0007", + "F\u0002\u0002\u11d3\u11d4\u0007K\u0002\u0002\u11d4\u11d5\u0007P\u0002", + "\u0002\u11d5\u11d6\u0007C\u0002\u0002\u11d6\u11d7\u0007N\u0002\u0002", + "\u11d7\u11d8\u0007K\u0002\u0002\u11d8\u11d9\u0007V\u0002\u0002\u11d9", + "\u11da\u0007[\u0002\u0002\u11da\u03ae\u0003\u0002\u0002\u0002\u11db", + "\u11dc\u0007Z\u0002\u0002\u11dc\u11dd\u0007O\u0002\u0002\u11dd\u11de", + "\u0007N\u0002\u0002\u11de\u11df\u0007V\u0002\u0002\u11df\u11e0\u0007", + "C\u0002\u0002\u11e0\u11e1\u0007D\u0002\u0002\u11e1\u11e2\u0007N\u0002", + "\u0002\u11e2\u11e3\u0007G\u0002\u0002\u11e3\u03b0\u0003\u0002\u0002", + "\u0002\u11e4\u11e5\u0007E\u0002\u0002\u11e5\u11e6\u0007Q\u0002\u0002", + "\u11e6\u11e7\u0007N\u0002\u0002\u11e7\u11e8\u0007W\u0002\u0002\u11e8", + "\u11e9\u0007O\u0002\u0002\u11e9\u11ea\u0007P\u0002\u0002\u11ea\u11eb", + "\u0007U\u0002\u0002\u11eb\u03b2\u0003\u0002\u0002\u0002\u11ec\u11ed", + "\u0007Z\u0002\u0002\u11ed\u11ee\u0007O\u0002\u0002\u11ee\u11ef\u0007", + "N\u0002\u0002\u11ef\u11f0\u0007P\u0002\u0002\u11f0\u11f1\u0007C\u0002", + "\u0002\u11f1\u11f2\u0007O\u0002\u0002\u11f2\u11f3\u0007G\u0002\u0002", + "\u11f3\u11f4\u0007U\u0002\u0002\u11f4\u11f5\u0007R\u0002\u0002\u11f5", + "\u11f6\u0007C\u0002\u0002\u11f6\u11f7\u0007E\u0002\u0002\u11f7\u11f8", + "\u0007G\u0002\u0002\u11f8\u11f9\u0007U\u0002\u0002\u11f9\u03b4\u0003", + "\u0002\u0002\u0002\u11fa\u11fb\u0007T\u0002\u0002\u11fb\u11fc\u0007", + "Q\u0002\u0002\u11fc\u11fd\u0007Y\u0002\u0002\u11fd\u11fe\u0007V\u0002", + "\u0002\u11fe\u11ff\u0007[\u0002\u0002\u11ff\u1200\u0007R\u0002\u0002", + "\u1200\u1201\u0007G\u0002\u0002\u1201\u03b6\u0003\u0002\u0002\u0002", + "\u1202\u1203\u0007P\u0002\u0002\u1203\u1204\u0007Q\u0002\u0002\u1204", + "\u1205\u0007T\u0002\u0002\u1205\u1206\u0007O\u0002\u0002\u1206\u1207", + "\u0007C\u0002\u0002\u1207\u1208\u0007N\u0002\u0002\u1208\u1209\u0007", + "K\u0002\u0002\u1209\u120a\u0007\\\u0002\u0002\u120a\u120b\u0007G\u0002", + "\u0002\u120b\u120c\u0007F\u0002\u0002\u120c\u03b8\u0003\u0002\u0002", + "\u0002\u120d\u120e\u0007Y\u0002\u0002\u120e\u120f\u0007K\u0002\u0002", + "\u120f\u1210\u0007V\u0002\u0002\u1210\u1211\u0007J\u0002\u0002\u1211", + "\u1212\u0007K\u0002\u0002\u1212\u1213\u0007P\u0002\u0002\u1213\u03ba", + "\u0003\u0002\u0002\u0002\u1214\u1215\u0007H\u0002\u0002\u1215\u1216", + "\u0007K\u0002\u0002\u1216\u1217\u0007N\u0002\u0002\u1217\u1218\u0007", + "V\u0002\u0002\u1218\u1219\u0007G\u0002\u0002\u1219\u121a\u0007T\u0002", + "\u0002\u121a\u03bc\u0003\u0002\u0002\u0002\u121b\u121c\u0007I\u0002", + "\u0002\u121c\u121d\u0007T\u0002\u0002\u121d\u121e\u0007Q\u0002\u0002", + "\u121e\u121f\u0007W\u0002\u0002\u121f\u1220\u0007R\u0002\u0002\u1220", + "\u1221\u0007U\u0002\u0002\u1221\u03be\u0003\u0002\u0002\u0002\u1222", + "\u1223\u0007Q\u0002\u0002\u1223\u1224\u0007V\u0002\u0002\u1224\u1225", + "\u0007J\u0002\u0002\u1225\u1226\u0007G\u0002\u0002\u1226\u1227\u0007", + "T\u0002\u0002\u1227\u1228\u0007U\u0002\u0002\u1228\u03c0\u0003\u0002", + "\u0002\u0002\u1229\u122a\u0007P\u0002\u0002\u122a\u122b\u0007H\u0002", + "\u0002\u122b\u122c\u0007E\u0002\u0002\u122c\u03c2\u0003\u0002\u0002", + "\u0002\u122d\u122e\u0007P\u0002\u0002\u122e\u122f\u0007H\u0002\u0002", + "\u122f\u1230\u0007F\u0002\u0002\u1230\u03c4\u0003\u0002\u0002\u0002", + "\u1231\u1232\u0007P\u0002\u0002\u1232\u1233\u0007H\u0002\u0002\u1233", + "\u1234\u0007M\u0002\u0002\u1234\u1235\u0007E\u0002\u0002\u1235\u03c6", + "\u0003\u0002\u0002\u0002\u1236\u1237\u0007P\u0002\u0002\u1237\u1238", + "\u0007H\u0002\u0002\u1238\u1239\u0007M\u0002\u0002\u1239\u123a\u0007", + "F\u0002\u0002\u123a\u03c8\u0003\u0002\u0002\u0002\u123b\u123c\u0007", + "W\u0002\u0002\u123c\u123d\u0007G\u0002\u0002\u123d\u123e\u0007U\u0002", + "\u0002\u123e\u123f\u0007E\u0002\u0002\u123f\u1240\u0007C\u0002\u0002", + "\u1240\u1241\u0007R\u0002\u0002\u1241\u1242\u0007G\u0002\u0002\u1242", + "\u03ca\u0003\u0002\u0002\u0002\u1243\u1244\u0007X\u0002\u0002\u1244", + "\u1245\u0007K\u0002\u0002\u1245\u1246\u0007G\u0002\u0002\u1246\u1247", + "\u0007Y\u0002\u0002\u1247\u1248\u0007U\u0002\u0002\u1248\u03cc\u0003", + "\u0002\u0002\u0002\u1249\u124a\u0007P\u0002\u0002\u124a\u124b\u0007", + "Q\u0002\u0002\u124b\u124c\u0007T\u0002\u0002\u124c\u124d\u0007O\u0002", + "\u0002\u124d\u124e\u0007C\u0002\u0002\u124e\u124f\u0007N\u0002\u0002", + "\u124f\u1250\u0007K\u0002\u0002\u1250\u1251\u0007\\\u0002\u0002\u1251", + "\u1252\u0007G\u0002\u0002\u1252\u03ce\u0003\u0002\u0002\u0002\u1253", + "\u1254\u0007F\u0002\u0002\u1254\u1255\u0007W\u0002\u0002\u1255\u1256", + "\u0007O\u0002\u0002\u1256\u1257\u0007R\u0002\u0002\u1257\u03d0\u0003", + "\u0002\u0002\u0002\u1258\u1259\u0007R\u0002\u0002\u1259\u125a\u0007", + "T\u0002\u0002\u125a\u125b\u0007K\u0002\u0002\u125b\u125c\u0007P\u0002", + "\u0002\u125c\u125d\u0007V\u0002\u0002\u125d\u125e\u0007a\u0002\u0002", + "\u125e\u125f\u0007U\u0002\u0002\u125f\u1260\u0007V\u0002\u0002\u1260", + "\u1261\u0007T\u0002\u0002\u1261\u1262\u0007K\u0002\u0002\u1262\u1263", + "\u0007E\u0002\u0002\u1263\u1264\u0007V\u0002\u0002\u1264\u1265\u0007", + "a\u0002\u0002\u1265\u1266\u0007R\u0002\u0002\u1266\u1267\u0007C\u0002", + "\u0002\u1267\u1268\u0007T\u0002\u0002\u1268\u1269\u0007C\u0002\u0002", + "\u1269\u126a\u0007O\u0002\u0002\u126a\u126b\u0007U\u0002\u0002\u126b", + "\u03d2\u0003\u0002\u0002\u0002\u126c\u126d\u0007X\u0002\u0002\u126d", + "\u126e\u0007C\u0002\u0002\u126e\u126f\u0007T\u0002\u0002\u126f\u1270", + "\u0007K\u0002\u0002\u1270\u1271\u0007C\u0002\u0002\u1271\u1272\u0007", + "D\u0002\u0002\u1272\u1273\u0007N\u0002\u0002\u1273\u1274\u0007G\u0002", + "\u0002\u1274\u1275\u0007a\u0002\u0002\u1275\u1276\u0007E\u0002\u0002", + "\u1276\u1277\u0007Q\u0002\u0002\u1277\u1278\u0007P\u0002\u0002\u1278", + "\u1279\u0007H\u0002\u0002\u1279\u127a\u0007N\u0002\u0002\u127a\u127b", + "\u0007K\u0002\u0002\u127b\u127c\u0007E\u0002\u0002\u127c\u127d\u0007", + "V\u0002\u0002\u127d\u03d4\u0003\u0002\u0002\u0002\u127e\u127f\u0007", + "G\u0002\u0002\u127f\u1280\u0007T\u0002\u0002\u1280\u1281\u0007T\u0002", + "\u0002\u1281\u1282\u0007Q\u0002\u0002\u1282\u1283\u0007T\u0002\u0002", + "\u1283\u03d6\u0003\u0002\u0002\u0002\u1284\u1285\u0007W\u0002\u0002", + "\u1285\u1286\u0007U\u0002\u0002\u1286\u1287\u0007G\u0002\u0002\u1287", + "\u1288\u0007a\u0002\u0002\u1288\u1289\u0007X\u0002\u0002\u1289\u128a", + "\u0007C\u0002\u0002\u128a\u128b\u0007T\u0002\u0002\u128b\u128c\u0007", + "K\u0002\u0002\u128c\u128d\u0007C\u0002\u0002\u128d\u128e\u0007D\u0002", + "\u0002\u128e\u128f\u0007N\u0002\u0002\u128f\u1290\u0007G\u0002\u0002", + "\u1290\u03d8\u0003\u0002\u0002\u0002\u1291\u1292\u0007W\u0002\u0002", + "\u1292\u1293\u0007U\u0002\u0002\u1293\u1294\u0007G\u0002\u0002\u1294", + "\u1295\u0007a\u0002\u0002\u1295\u1296\u0007E\u0002\u0002\u1296\u1297", + "\u0007Q\u0002\u0002\u1297\u1298\u0007N\u0002\u0002\u1298\u1299\u0007", + "W\u0002\u0002\u1299\u129a\u0007O\u0002\u0002\u129a\u129b\u0007P\u0002", + "\u0002\u129b\u03da\u0003\u0002\u0002\u0002\u129c\u129d\u0007C\u0002", + "\u0002\u129d\u129e\u0007N\u0002\u0002\u129e\u129f\u0007K\u0002\u0002", + "\u129f\u12a0\u0007C\u0002\u0002\u12a0\u12a1\u0007U\u0002\u0002\u12a1", + "\u03dc\u0003\u0002\u0002\u0002\u12a2\u12a3\u0007E\u0002\u0002\u12a3", + "\u12a4\u0007Q\u0002\u0002\u12a4\u12a5\u0007P\u0002\u0002\u12a5\u12a6", + "\u0007U\u0002\u0002\u12a6\u12a7\u0007V\u0002\u0002\u12a7\u12a8\u0007", + "C\u0002\u0002\u12a8\u12a9\u0007P\u0002\u0002\u12a9\u12aa\u0007V\u0002", + "\u0002\u12aa\u03de\u0003\u0002\u0002\u0002\u12ab\u12ac\u0007R\u0002", + "\u0002\u12ac\u12ad\u0007G\u0002\u0002\u12ad\u12ae\u0007T\u0002\u0002", + "\u12ae\u12af\u0007H\u0002\u0002\u12af\u12b0\u0007Q\u0002\u0002\u12b0", + "\u12b1\u0007T\u0002\u0002\u12b1\u12b2\u0007O\u0002\u0002\u12b2\u03e0", + "\u0003\u0002\u0002\u0002\u12b3\u12b4\u0007I\u0002\u0002\u12b4\u12b5", + "\u0007G\u0002\u0002\u12b5\u12b6\u0007V\u0002\u0002\u12b6\u03e2\u0003", + "\u0002\u0002\u0002\u12b7\u12b8\u0007F\u0002\u0002\u12b8\u12b9\u0007", + "K\u0002\u0002\u12b9\u12ba\u0007C\u0002\u0002\u12ba\u12bb\u0007I\u0002", + "\u0002\u12bb\u12bc\u0007P\u0002\u0002\u12bc\u12bd\u0007Q\u0002\u0002", + "\u12bd\u12be\u0007U\u0002\u0002\u12be\u12bf\u0007V\u0002\u0002\u12bf", + "\u12c0\u0007K\u0002\u0002\u12c0\u12c1\u0007E\u0002\u0002\u12c1\u12c2", + "\u0007U\u0002\u0002\u12c2\u03e4\u0003\u0002\u0002\u0002\u12c3\u12c4", + "\u0007U\u0002\u0002\u12c4\u12c5\u0007V\u0002\u0002\u12c5\u12c6\u0007", + "C\u0002\u0002\u12c6\u12c7\u0007E\u0002\u0002\u12c7\u12c8\u0007M\u0002", + "\u0002\u12c8\u12c9\u0007G\u0002\u0002\u12c9\u12ca\u0007F\u0002\u0002", + "\u12ca\u03e6\u0003\u0002\u0002\u0002\u12cb\u12cc\u0007G\u0002\u0002", + "\u12cc\u12cd\u0007N\u0002\u0002\u12cd\u12ce\u0007U\u0002\u0002\u12ce", + "\u12cf\u0007K\u0002\u0002\u12cf\u12d0\u0007H\u0002\u0002\u12d0\u03e8", + "\u0003\u0002\u0002\u0002\u12d1\u12d2\u0007Y\u0002\u0002\u12d2\u12d3", + "\u0007J\u0002\u0002\u12d3\u12d4\u0007K\u0002\u0002\u12d4\u12d5\u0007", + "N\u0002\u0002\u12d5\u12d6\u0007G\u0002\u0002\u12d6\u03ea\u0003\u0002", + "\u0002\u0002\u12d7\u12d8\u0007T\u0002\u0002\u12d8\u12d9\u0007G\u0002", + "\u0002\u12d9\u12da\u0007X\u0002\u0002\u12da\u12db\u0007G\u0002\u0002", + "\u12db\u12dc\u0007T\u0002\u0002\u12dc\u12dd\u0007U\u0002\u0002\u12dd", + "\u12de\u0007G\u0002\u0002\u12de\u03ec\u0003\u0002\u0002\u0002\u12df", + "\u12e0\u0007H\u0002\u0002\u12e0\u12e1\u0007Q\u0002\u0002\u12e1\u12e2", + "\u0007T\u0002\u0002\u12e2\u12e3\u0007G\u0002\u0002\u12e3\u12e4\u0007", + "C\u0002\u0002\u12e4\u12e5\u0007E\u0002\u0002\u12e5\u12e6\u0007J\u0002", + "\u0002\u12e6\u03ee\u0003\u0002\u0002\u0002\u12e7\u12e8\u0007U\u0002", + "\u0002\u12e8\u12e9\u0007N\u0002\u0002\u12e9\u12ea\u0007K\u0002\u0002", + "\u12ea\u12eb\u0007E\u0002\u0002\u12eb\u12ec\u0007G\u0002\u0002\u12ec", + "\u03f0\u0003\u0002\u0002\u0002\u12ed\u12ee\u0007G\u0002\u0002\u12ee", + "\u12ef\u0007Z\u0002\u0002\u12ef\u12f0\u0007K\u0002\u0002\u12f0\u12f1", + "\u0007V\u0002\u0002\u12f1\u03f2\u0003\u0002\u0002\u0002\u12f2\u12f3", + "\u0007T\u0002\u0002\u12f3\u12f4\u0007G\u0002\u0002\u12f4\u12f5\u0007", + "V\u0002\u0002\u12f5\u12f6\u0007W\u0002\u0002\u12f6\u12f7\u0007T\u0002", + "\u0002\u12f7\u12f8\u0007P\u0002\u0002\u12f8\u03f4\u0003\u0002\u0002", + "\u0002\u12f9\u12fa\u0007S\u0002\u0002\u12fa\u12fb\u0007W\u0002\u0002", + "\u12fb\u12fc\u0007G\u0002\u0002\u12fc\u12fd\u0007T\u0002\u0002\u12fd", + "\u12fe\u0007[\u0002\u0002\u12fe\u03f6\u0003\u0002\u0002\u0002\u12ff", + "\u1300\u0007T\u0002\u0002\u1300\u1301\u0007C\u0002\u0002\u1301\u1302", + "\u0007K\u0002\u0002\u1302\u1303\u0007U\u0002\u0002\u1303\u1304\u0007", + "G\u0002\u0002\u1304\u03f8\u0003\u0002\u0002\u0002\u1305\u1306\u0007", + "U\u0002\u0002\u1306\u1307\u0007S\u0002\u0002\u1307\u1308\u0007N\u0002", + "\u0002\u1308\u1309\u0007U\u0002\u0002\u1309\u130a\u0007V\u0002\u0002", + "\u130a\u130b\u0007C\u0002\u0002\u130b\u130c\u0007V\u0002\u0002\u130c", + "\u130d\u0007G\u0002\u0002\u130d\u03fa\u0003\u0002\u0002\u0002\u130e", + "\u130f\u0007F\u0002\u0002\u130f\u1310\u0007G\u0002\u0002\u1310\u1311", + "\u0007D\u0002\u0002\u1311\u1312\u0007W\u0002\u0002\u1312\u1313\u0007", + "I\u0002\u0002\u1313\u03fc\u0003\u0002\u0002\u0002\u1314\u1315\u0007", + "N\u0002\u0002\u1315\u1316\u0007Q\u0002\u0002\u1316\u1317\u0007I\u0002", + "\u0002\u1317\u03fe\u0003\u0002\u0002\u0002\u1318\u1319\u0007K\u0002", + "\u0002\u1319\u131a\u0007P\u0002\u0002\u131a\u131b\u0007H\u0002\u0002", + "\u131b\u131c\u0007Q\u0002\u0002\u131c\u0400\u0003\u0002\u0002\u0002", + "\u131d\u131e\u0007P\u0002\u0002\u131e\u131f\u0007Q\u0002\u0002\u131f", + "\u1320\u0007V\u0002\u0002\u1320\u1321\u0007K\u0002\u0002\u1321\u1322", + "\u0007E\u0002\u0002\u1322\u1323\u0007G\u0002\u0002\u1323\u0402\u0003", + "\u0002\u0002\u0002\u1324\u1325\u0007Y\u0002\u0002\u1325\u1326\u0007", + "C\u0002\u0002\u1326\u1327\u0007T\u0002\u0002\u1327\u1328\u0007P\u0002", + "\u0002\u1328\u1329\u0007K\u0002\u0002\u1329\u132a\u0007P\u0002\u0002", + "\u132a\u132b\u0007I\u0002\u0002\u132b\u0404\u0003\u0002\u0002\u0002", + "\u132c\u132d\u0007G\u0002\u0002\u132d\u132e\u0007Z\u0002\u0002\u132e", + "\u132f\u0007E\u0002\u0002\u132f\u1330\u0007G\u0002\u0002\u1330\u1331", + "\u0007R\u0002\u0002\u1331\u1332\u0007V\u0002\u0002\u1332\u1333\u0007", + "K\u0002\u0002\u1333\u1334\u0007Q\u0002\u0002\u1334\u1335\u0007P\u0002", + "\u0002\u1335\u0406\u0003\u0002\u0002\u0002\u1336\u1337\u0007C\u0002", + "\u0002\u1337\u1338\u0007U\u0002\u0002\u1338\u1339\u0007U\u0002\u0002", + "\u1339\u133a\u0007G\u0002\u0002\u133a\u133b\u0007T\u0002\u0002\u133b", + "\u133c\u0007V\u0002\u0002\u133c\u0408\u0003\u0002\u0002\u0002\u133d", + "\u133e\u0007N\u0002\u0002\u133e\u133f\u0007Q\u0002\u0002\u133f\u1340", + "\u0007Q\u0002\u0002\u1340\u1341\u0007R\u0002\u0002\u1341\u040a\u0003", + "\u0002\u0002\u0002\u1342\u1343\u0007Q\u0002\u0002\u1343\u1344\u0007", + "R\u0002\u0002\u1344\u1345\u0007G\u0002\u0002\u1345\u1346\u0007P\u0002", + "\u0002\u1346\u040c\u0003\u0002\u0002\u0002\u1347\u134b\u0005\u040f\u0206", + "\u0002\u1348\u134a\u0005\u0411\u0207\u0002\u1349\u1348\u0003\u0002\u0002", + "\u0002\u134a\u134d\u0003\u0002\u0002\u0002\u134b\u1349\u0003\u0002\u0002", + "\u0002\u134b\u134c\u0003\u0002\u0002\u0002\u134c\u040e\u0003\u0002\u0002", + "\u0002\u134d\u134b\u0003\u0002\u0002\u0002\u134e\u1355\t\u0007\u0002", + "\u0002\u134f\u1350\t\b\u0002\u0002\u1350\u1355\u0006\u0206\b\u0002\u1351", + "\u1352\t\t\u0002\u0002\u1352\u1353\t\n\u0002\u0002\u1353\u1355\u0006", + "\u0206\t\u0002\u1354\u134e\u0003\u0002\u0002\u0002\u1354\u134f\u0003", + "\u0002\u0002\u0002\u1354\u1351\u0003\u0002\u0002\u0002\u1355\u0410\u0003", + "\u0002\u0002\u0002\u1356\u1359\u0005\u0413\u0208\u0002\u1357\u1359\u0007", + "&\u0002\u0002\u1358\u1356\u0003\u0002\u0002\u0002\u1358\u1357\u0003", + "\u0002\u0002\u0002\u1359\u0412\u0003\u0002\u0002\u0002\u135a\u135d\u0005", + "\u040f\u0206\u0002\u135b\u135d\t\u0002\u0002\u0002\u135c\u135a\u0003", + "\u0002\u0002\u0002\u135c\u135b\u0003\u0002\u0002\u0002\u135d\u0414\u0003", + "\u0002\u0002\u0002\u135e\u135f\u0005\u0417\u020a\u0002\u135f\u1360\u0007", + "$\u0002\u0002\u1360\u0416\u0003\u0002\u0002\u0002\u1361\u1367\u0007", + "$\u0002\u0002\u1362\u1363\u0007$\u0002\u0002\u1363\u1366\u0007$\u0002", + "\u0002\u1364\u1366\n\u000b\u0002\u0002\u1365\u1362\u0003\u0002\u0002", + "\u0002\u1365\u1364\u0003\u0002\u0002\u0002\u1366\u1369\u0003\u0002\u0002", + "\u0002\u1367\u1365\u0003\u0002\u0002\u0002\u1367\u1368\u0003\u0002\u0002", + "\u0002\u1368\u0418\u0003\u0002\u0002\u0002\u1369\u1367\u0003\u0002\u0002", + "\u0002\u136a\u136b\u0005\u041b\u020c\u0002\u136b\u136c\u0007$\u0002", + "\u0002\u136c\u041a\u0003\u0002\u0002\u0002\u136d\u1373\u0007$\u0002", + "\u0002\u136e\u136f\u0007$\u0002\u0002\u136f\u1372\u0007$\u0002\u0002", + "\u1370\u1372\n\f\u0002\u0002\u1371\u136e\u0003\u0002\u0002\u0002\u1371", + "\u1370\u0003\u0002\u0002\u0002\u1372\u1375\u0003\u0002\u0002\u0002\u1373", + "\u1371\u0003\u0002\u0002\u0002\u1373\u1374\u0003\u0002\u0002\u0002\u1374", + "\u041c\u0003\u0002\u0002\u0002\u1375\u1373\u0003\u0002\u0002\u0002\u1376", + "\u1377\u0007W\u0002\u0002\u1377\u1378\u0007(\u0002\u0002\u1378\u1379", + "\u0005\u0415\u0209\u0002\u1379\u041e\u0003\u0002\u0002\u0002\u137a\u137b", + "\u0007W\u0002\u0002\u137b\u137c\u0007(\u0002\u0002\u137c\u137d\u0005", + "\u0417\u020a\u0002\u137d\u0420\u0003\u0002\u0002\u0002\u137e\u137f\u0007", + "W\u0002\u0002\u137f\u1380\u0007(\u0002\u0002\u1380\u1381\u0005\u0419", + "\u020b\u0002\u1381\u0422\u0003\u0002\u0002\u0002\u1382\u1383\u0007W", + "\u0002\u0002\u1383\u1384\u0007(\u0002\u0002\u1384\u1385\u0005\u041b", + "\u020c\u0002\u1385\u0424\u0003\u0002\u0002\u0002\u1386\u1387\u0005\u0427", + "\u0212\u0002\u1387\u1388\u0007)\u0002\u0002\u1388\u0426\u0003\u0002", + "\u0002\u0002\u1389\u138f\u0007)\u0002\u0002\u138a\u138b\u0007)\u0002", + "\u0002\u138b\u138e\u0007)\u0002\u0002\u138c\u138e\n\r\u0002\u0002\u138d", + "\u138a\u0003\u0002\u0002\u0002\u138d\u138c\u0003\u0002\u0002\u0002\u138e", + "\u1391\u0003\u0002\u0002\u0002\u138f\u138d\u0003\u0002\u0002\u0002\u138f", + "\u1390\u0003\u0002\u0002\u0002\u1390\u0428\u0003\u0002\u0002\u0002\u1391", + "\u138f\u0003\u0002\u0002\u0002\u1392\u1393\u0007G\u0002\u0002\u1393", + "\u1394\u0007)\u0002\u0002\u1394\u1395\u0003\u0002\u0002\u0002\u1395", + "\u1396\b\u0213\u0004\u0002\u1396\u1397\b\u0213\u0005\u0002\u1397\u042a", + "\u0003\u0002\u0002\u0002\u1398\u1399\u0005\u042d\u0215\u0002\u1399\u139a", + "\u0007)\u0002\u0002\u139a\u042c\u0003\u0002\u0002\u0002\u139b\u139c", + "\u0007W\u0002\u0002\u139c\u139d\u0007(\u0002\u0002\u139d\u139e\u0005", + "\u0427\u0212\u0002\u139e\u042e\u0003\u0002\u0002\u0002\u139f\u13a1\u0007", + "&\u0002\u0002\u13a0\u13a2\u0005\u0431\u0217\u0002\u13a1\u13a0\u0003", + "\u0002\u0002\u0002\u13a1\u13a2\u0003\u0002\u0002\u0002\u13a2\u13a3\u0003", + "\u0002\u0002\u0002\u13a3\u13a4\u0007&\u0002\u0002\u13a4\u13a5\b\u0216", + "\u0006\u0002\u13a5\u13a6\u0003\u0002\u0002\u0002\u13a6\u13a7\b\u0216", + "\u0007\u0002\u13a7\u0430\u0003\u0002\u0002\u0002\u13a8\u13ac\u0005\u040f", + "\u0206\u0002\u13a9\u13ab\u0005\u0413\u0208\u0002\u13aa\u13a9\u0003\u0002", + "\u0002\u0002\u13ab\u13ae\u0003\u0002\u0002\u0002\u13ac\u13aa\u0003\u0002", + "\u0002\u0002\u13ac\u13ad\u0003\u0002\u0002\u0002\u13ad\u0432\u0003\u0002", + "\u0002\u0002\u13ae\u13ac\u0003\u0002\u0002\u0002\u13af\u13b0\u0005\u0435", + "\u0219\u0002\u13b0\u13b1\u0007)\u0002\u0002\u13b1\u0434\u0003\u0002", + "\u0002\u0002\u13b2\u13b3\u0007D\u0002\u0002\u13b3\u13b7\u0007)\u0002", + "\u0002\u13b4\u13b6\t\u000e\u0002\u0002\u13b5\u13b4\u0003\u0002\u0002", + "\u0002\u13b6\u13b9\u0003\u0002\u0002\u0002\u13b7\u13b5\u0003\u0002\u0002", + "\u0002\u13b7\u13b8\u0003\u0002\u0002\u0002\u13b8\u0436\u0003\u0002\u0002", + "\u0002\u13b9\u13b7\u0003\u0002\u0002\u0002\u13ba\u13bb\u0005\u0439\u021b", + "\u0002\u13bb\u13bc\u0007)\u0002\u0002\u13bc\u0438\u0003\u0002\u0002", + "\u0002\u13bd\u13be\u0007D\u0002\u0002\u13be\u13bf\u0005\u0427\u0212", + "\u0002\u13bf\u043a\u0003\u0002\u0002\u0002\u13c0\u13c1\u0005\u043d\u021d", + "\u0002\u13c1\u13c2\u0007)\u0002\u0002\u13c2\u043c\u0003\u0002\u0002", + "\u0002\u13c3\u13c4\u0007Z\u0002\u0002\u13c4\u13c8\u0007)\u0002\u0002", + "\u13c5\u13c7\t\u000f\u0002\u0002\u13c6\u13c5\u0003\u0002\u0002\u0002", + "\u13c7\u13ca\u0003\u0002\u0002\u0002\u13c8\u13c6\u0003\u0002\u0002\u0002", + "\u13c8\u13c9\u0003\u0002\u0002\u0002\u13c9\u043e\u0003\u0002\u0002\u0002", + "\u13ca\u13c8\u0003\u0002\u0002\u0002\u13cb\u13cc\u0005\u0441\u021f\u0002", + "\u13cc\u13cd\u0007)\u0002\u0002\u13cd\u0440\u0003\u0002\u0002\u0002", + "\u13ce\u13cf\u0007Z\u0002\u0002\u13cf\u13d0\u0005\u0427\u0212\u0002", + "\u13d0\u0442\u0003\u0002\u0002\u0002\u13d1\u13d2\u0005\u0449\u0223\u0002", + "\u13d2\u0444\u0003\u0002\u0002\u0002\u13d3\u13d4\u0005\u0449\u0223\u0002", + "\u13d4\u13d5\u00070\u0002\u0002\u13d5\u13d6\u00070\u0002\u0002\u13d6", + "\u13d7\u0003\u0002\u0002\u0002\u13d7\u13d8\b\u0221\b\u0002\u13d8\u0446", + "\u0003\u0002\u0002\u0002\u13d9\u13da\u0005\u0449\u0223\u0002\u13da\u13dc", + "\u00070\u0002\u0002\u13db\u13dd\u0005\u0449\u0223\u0002\u13dc\u13db", + "\u0003\u0002\u0002\u0002\u13dc\u13dd\u0003\u0002\u0002\u0002\u13dd\u13e3", + "\u0003\u0002\u0002\u0002\u13de\u13e0\u0007G\u0002\u0002\u13df\u13e1", + "\t\u0003\u0002\u0002\u13e0\u13df\u0003\u0002\u0002\u0002\u13e0\u13e1", + "\u0003\u0002\u0002\u0002\u13e1\u13e2\u0003\u0002\u0002\u0002\u13e2\u13e4", + "\u0005\u0449\u0223\u0002\u13e3\u13de\u0003\u0002\u0002\u0002\u13e3\u13e4", + "\u0003\u0002\u0002\u0002\u13e4\u13f6\u0003\u0002\u0002\u0002\u13e5\u13e6", + "\u00070\u0002\u0002\u13e6\u13ec\u0005\u0449\u0223\u0002\u13e7\u13e9", + "\u0007G\u0002\u0002\u13e8\u13ea\t\u0003\u0002\u0002\u13e9\u13e8\u0003", + "\u0002\u0002\u0002\u13e9\u13ea\u0003\u0002\u0002\u0002\u13ea\u13eb\u0003", + "\u0002\u0002\u0002\u13eb\u13ed\u0005\u0449\u0223\u0002\u13ec\u13e7\u0003", + "\u0002\u0002\u0002\u13ec\u13ed\u0003\u0002\u0002\u0002\u13ed\u13f6\u0003", + "\u0002\u0002\u0002\u13ee\u13ef\u0005\u0449\u0223\u0002\u13ef\u13f1\u0007", + "G\u0002\u0002\u13f0\u13f2\t\u0003\u0002\u0002\u13f1\u13f0\u0003\u0002", + "\u0002\u0002\u13f1\u13f2\u0003\u0002\u0002\u0002\u13f2\u13f3\u0003\u0002", + "\u0002\u0002\u13f3\u13f4\u0005\u0449\u0223\u0002\u13f4\u13f6\u0003\u0002", + "\u0002\u0002\u13f5\u13d9\u0003\u0002\u0002\u0002\u13f5\u13e5\u0003\u0002", + "\u0002\u0002\u13f5\u13ee\u0003\u0002\u0002\u0002\u13f6\u0448\u0003\u0002", + "\u0002\u0002\u13f7\u13f9\t\u0002\u0002\u0002\u13f8\u13f7\u0003\u0002", + "\u0002\u0002\u13f9\u13fa\u0003\u0002\u0002\u0002\u13fa\u13f8\u0003\u0002", + "\u0002\u0002\u13fa\u13fb\u0003\u0002\u0002\u0002\u13fb\u044a\u0003\u0002", + "\u0002\u0002\u13fc\u13fd\u0007<\u0002\u0002\u13fd\u1401\t\u0010\u0002", + "\u0002\u13fe\u1400\t\u0011\u0002\u0002\u13ff\u13fe\u0003\u0002\u0002", + "\u0002\u1400\u1403\u0003\u0002\u0002\u0002\u1401\u13ff\u0003\u0002\u0002", + "\u0002\u1401\u1402\u0003\u0002\u0002\u0002\u1402\u044c\u0003\u0002\u0002", + "\u0002\u1403\u1401\u0003\u0002\u0002\u0002\u1404\u1405\u0007<\u0002", + "\u0002\u1405\u1406\u0007$\u0002\u0002\u1406\u140e\u0003\u0002\u0002", + "\u0002\u1407\u1408\u0007^\u0002\u0002\u1408\u140d\u000b\u0002\u0002", + "\u0002\u1409\u140a\u0007$\u0002\u0002\u140a\u140d\u0007$\u0002\u0002", + "\u140b\u140d\n\u0012\u0002\u0002\u140c\u1407\u0003\u0002\u0002\u0002", + "\u140c\u1409\u0003\u0002\u0002\u0002\u140c\u140b\u0003\u0002\u0002\u0002", + "\u140d\u1410\u0003\u0002\u0002\u0002\u140e\u140c\u0003\u0002\u0002\u0002", + "\u140e\u140f\u0003\u0002\u0002\u0002\u140f\u1411\u0003\u0002\u0002\u0002", + "\u1410\u140e\u0003\u0002\u0002\u0002\u1411\u1412\u0007$\u0002\u0002", + "\u1412\u044e\u0003\u0002\u0002\u0002\u1413\u1415\t\u0013\u0002\u0002", + "\u1414\u1413\u0003\u0002\u0002\u0002\u1415\u1416\u0003\u0002\u0002\u0002", + "\u1416\u1414\u0003\u0002\u0002\u0002\u1416\u1417\u0003\u0002\u0002\u0002", + "\u1417\u1418\u0003\u0002\u0002\u0002\u1418\u1419\b\u0226\t\u0002\u1419", + "\u0450\u0003\u0002\u0002\u0002\u141a\u141c\u0007\u000f\u0002\u0002\u141b", + "\u141d\u0007\f\u0002\u0002\u141c\u141b\u0003\u0002\u0002\u0002\u141c", + "\u141d\u0003\u0002\u0002\u0002\u141d\u1420\u0003\u0002\u0002\u0002\u141e", + "\u1420\u0007\f\u0002\u0002\u141f\u141a\u0003\u0002\u0002\u0002\u141f", + "\u141e\u0003\u0002\u0002\u0002\u1420\u1421\u0003\u0002\u0002\u0002\u1421", + "\u1422\b\u0227\t\u0002\u1422\u0452\u0003\u0002\u0002\u0002\u1423\u1424", + "\u0007/\u0002\u0002\u1424\u1425\u0007/\u0002\u0002\u1425\u1429\u0003", + "\u0002\u0002\u0002\u1426\u1428\n\u0014\u0002\u0002\u1427\u1426\u0003", + "\u0002\u0002\u0002\u1428\u142b\u0003\u0002\u0002\u0002\u1429\u1427\u0003", + "\u0002\u0002\u0002\u1429\u142a\u0003\u0002\u0002\u0002\u142a\u142c\u0003", + "\u0002\u0002\u0002\u142b\u1429\u0003\u0002\u0002\u0002\u142c\u142d\b", + "\u0228\t\u0002\u142d\u0454\u0003\u0002\u0002\u0002\u142e\u142f\u0007", + "1\u0002\u0002\u142f\u1430\u0007,\u0002\u0002\u1430\u1447\u0003\u0002", + "\u0002\u0002\u1431\u1433\u00071\u0002\u0002\u1432\u1431\u0003\u0002", + "\u0002\u0002\u1433\u1436\u0003\u0002\u0002\u0002\u1434\u1432\u0003\u0002", + "\u0002\u0002\u1434\u1435\u0003\u0002\u0002\u0002\u1435\u1437\u0003\u0002", + "\u0002\u0002\u1436\u1434\u0003\u0002\u0002\u0002\u1437\u1446\u0005\u0455", + "\u0229\u0002\u1438\u1446\n\u0015\u0002\u0002\u1439\u143b\u00071\u0002", + "\u0002\u143a\u1439\u0003\u0002\u0002\u0002\u143b\u143c\u0003\u0002\u0002", + "\u0002\u143c\u143a\u0003\u0002\u0002\u0002\u143c\u143d\u0003\u0002\u0002", + "\u0002\u143d\u143e\u0003\u0002\u0002\u0002\u143e\u1446\n\u0015\u0002", + "\u0002\u143f\u1441\u0007,\u0002\u0002\u1440\u143f\u0003\u0002\u0002", + "\u0002\u1441\u1442\u0003\u0002\u0002\u0002\u1442\u1440\u0003\u0002\u0002", + "\u0002\u1442\u1443\u0003\u0002\u0002\u0002\u1443\u1444\u0003\u0002\u0002", + "\u0002\u1444\u1446\n\u0015\u0002\u0002\u1445\u1434\u0003\u0002\u0002", + "\u0002\u1445\u1438\u0003\u0002\u0002\u0002\u1445\u143a\u0003\u0002\u0002", + "\u0002\u1445\u1440\u0003\u0002\u0002\u0002\u1446\u1449\u0003\u0002\u0002", + "\u0002\u1447\u1445\u0003\u0002\u0002\u0002\u1447\u1448\u0003\u0002\u0002", + "\u0002\u1448\u144d\u0003\u0002\u0002\u0002\u1449\u1447\u0003\u0002\u0002", + "\u0002\u144a\u144c\u0007,\u0002\u0002\u144b\u144a\u0003\u0002\u0002", + "\u0002\u144c\u144f\u0003\u0002\u0002\u0002\u144d\u144b\u0003\u0002\u0002", + "\u0002\u144d\u144e\u0003\u0002\u0002\u0002\u144e\u1450\u0003\u0002\u0002", + "\u0002\u144f\u144d\u0003\u0002\u0002\u0002\u1450\u1451\u0007,\u0002", + "\u0002\u1451\u1452\u00071\u0002\u0002\u1452\u1453\u0003\u0002\u0002", + "\u0002\u1453\u1454\b\u0229\t\u0002\u1454\u0456\u0003\u0002\u0002\u0002", + "\u1455\u1456\u00071\u0002\u0002\u1456\u1457\u0007,\u0002\u0002\u1457", + "\u1470\u0003\u0002\u0002\u0002\u1458\u145a\u00071\u0002\u0002\u1459", + "\u1458\u0003\u0002\u0002\u0002\u145a\u145d\u0003\u0002\u0002\u0002\u145b", + "\u1459\u0003\u0002\u0002\u0002\u145b\u145c\u0003\u0002\u0002\u0002\u145c", + "\u145e\u0003\u0002\u0002\u0002\u145d\u145b\u0003\u0002\u0002\u0002\u145e", + "\u146f\u0005\u0455\u0229\u0002\u145f\u146f\n\u0015\u0002\u0002\u1460", + "\u1462\u00071\u0002\u0002\u1461\u1460\u0003\u0002\u0002\u0002\u1462", + "\u1463\u0003\u0002\u0002\u0002\u1463\u1461\u0003\u0002\u0002\u0002\u1463", + "\u1464\u0003\u0002\u0002\u0002\u1464\u1465\u0003\u0002\u0002\u0002\u1465", + "\u146d\n\u0015\u0002\u0002\u1466\u1468\u0007,\u0002\u0002\u1467\u1466", + "\u0003\u0002\u0002\u0002\u1468\u1469\u0003\u0002\u0002\u0002\u1469\u1467", + "\u0003\u0002\u0002\u0002\u1469\u146a\u0003\u0002\u0002\u0002\u146a\u146b", + "\u0003\u0002\u0002\u0002\u146b\u146d\n\u0015\u0002\u0002\u146c\u1461", + "\u0003\u0002\u0002\u0002\u146c\u1467\u0003\u0002\u0002\u0002\u146d\u146f", + "\u0003\u0002\u0002\u0002\u146e\u145b\u0003\u0002\u0002\u0002\u146e\u145f", + "\u0003\u0002\u0002\u0002\u146e\u146c\u0003\u0002\u0002\u0002\u146f\u1472", + "\u0003\u0002\u0002\u0002\u1470\u146e\u0003\u0002\u0002\u0002\u1470\u1471", + "\u0003\u0002\u0002\u0002\u1471\u1484\u0003\u0002\u0002\u0002\u1472\u1470", + "\u0003\u0002\u0002\u0002\u1473\u1475\u00071\u0002\u0002\u1474\u1473", + "\u0003\u0002\u0002\u0002\u1475\u1476\u0003\u0002\u0002\u0002\u1476\u1474", + "\u0003\u0002\u0002\u0002\u1476\u1477\u0003\u0002\u0002\u0002\u1477\u1485", + "\u0003\u0002\u0002\u0002\u1478\u147a\u0007,\u0002\u0002\u1479\u1478", + "\u0003\u0002\u0002\u0002\u147a\u147b\u0003\u0002\u0002\u0002\u147b\u1479", + "\u0003\u0002\u0002\u0002\u147b\u147c\u0003\u0002\u0002\u0002\u147c\u1485", + "\u0003\u0002\u0002\u0002\u147d\u147f\u00071\u0002\u0002\u147e\u147d", + "\u0003\u0002\u0002\u0002\u147f\u1482\u0003\u0002\u0002\u0002\u1480\u147e", + "\u0003\u0002\u0002\u0002\u1480\u1481\u0003\u0002\u0002\u0002\u1481\u1483", + "\u0003\u0002\u0002\u0002\u1482\u1480\u0003\u0002\u0002\u0002\u1483\u1485", + "\u0005\u0457\u022a\u0002\u1484\u1474\u0003\u0002\u0002\u0002\u1484\u1479", + "\u0003\u0002\u0002\u0002\u1484\u1480\u0003\u0002\u0002\u0002\u1484\u1485", + "\u0003\u0002\u0002\u0002\u1485\u1486\u0003\u0002\u0002\u0002\u1486\u1487", + "\b\u022a\n\u0002\u1487\u0458\u0003\u0002\u0002\u0002\u1488\u1494\u0007", + "^\u0002\u0002\u1489\u1493\n\u0016\u0002\u0002\u148a\u148e\u0007$\u0002", + "\u0002\u148b\u148d\n\u0017\u0002\u0002\u148c\u148b\u0003\u0002\u0002", + "\u0002\u148d\u1490\u0003\u0002\u0002\u0002\u148e\u148c\u0003\u0002\u0002", + "\u0002\u148e\u148f\u0003\u0002\u0002\u0002\u148f\u1491\u0003\u0002\u0002", + "\u0002\u1490\u148e\u0003\u0002\u0002\u0002\u1491\u1493\u0007$\u0002", + "\u0002\u1492\u1489\u0003\u0002\u0002\u0002\u1492\u148a\u0003\u0002\u0002", + "\u0002\u1493\u1496\u0003\u0002\u0002\u0002\u1494\u1492\u0003\u0002\u0002", + "\u0002\u1494\u1495\u0003\u0002\u0002\u0002\u1495\u149e\u0003\u0002\u0002", + "\u0002\u1496\u1494\u0003\u0002\u0002\u0002\u1497\u149b\u0007$\u0002", + "\u0002\u1498\u149a\n\u0017\u0002\u0002\u1499\u1498\u0003\u0002\u0002", + "\u0002\u149a\u149d\u0003\u0002\u0002\u0002\u149b\u1499\u0003\u0002\u0002", + "\u0002\u149b\u149c\u0003\u0002\u0002\u0002\u149c\u149f\u0003\u0002\u0002", + "\u0002\u149d\u149b\u0003\u0002\u0002\u0002\u149e\u1497\u0003\u0002\u0002", + "\u0002\u149e\u149f\u0003\u0002\u0002\u0002\u149f\u045a\u0003\u0002\u0002", + "\u0002\u14a0\u14a1\u0007^\u0002\u0002\u14a1\u14a2\u0007^\u0002\u0002", + "\u14a2\u045c\u0003\u0002\u0002\u0002\u14a3\u14a4\u000b\u0002\u0002\u0002", + "\u14a4\u045e\u0003\u0002\u0002\u0002\u14a5\u14a6\u0005\u0463\u0230\u0002", + "\u14a6\u14a7\u0007)\u0002\u0002\u14a7\u14a8\u0003\u0002\u0002\u0002", + "\u14a8\u14a9\b\u022e\u000b\u0002\u14a9\u0460\u0003\u0002\u0002\u0002", + "\u14aa\u14ac\u0005\u0463\u0230\u0002\u14ab\u14ad\u0007^\u0002\u0002", + "\u14ac\u14ab\u0003\u0002\u0002\u0002\u14ac\u14ad\u0003\u0002\u0002\u0002", + "\u14ad\u14ae\u0003\u0002\u0002\u0002\u14ae\u14af\u0007\u0002\u0002\u0003", + "\u14af\u0462\u0003\u0002\u0002\u0002\u14b0\u14b1\u0007)\u0002\u0002", + "\u14b1\u14c8\u0007)\u0002\u0002\u14b2\u14c4\u0007^\u0002\u0002\u14b3", + "\u14b4\u0007z\u0002\u0002\u14b4\u14c5\t\u0018\u0002\u0002\u14b5\u14b6", + "\u0007w\u0002\u0002\u14b6\u14b7\t\u0018\u0002\u0002\u14b7\u14b8\t\u0018", + "\u0002\u0002\u14b8\u14b9\t\u0018\u0002\u0002\u14b9\u14c5\t\u0018\u0002", + "\u0002\u14ba\u14bb\u0007W\u0002\u0002\u14bb\u14bc\t\u0018\u0002\u0002", + "\u14bc\u14bd\t\u0018\u0002\u0002\u14bd\u14be\t\u0018\u0002\u0002\u14be", + "\u14bf\t\u0018\u0002\u0002\u14bf\u14c0\t\u0018\u0002\u0002\u14c0\u14c1", + "\t\u0018\u0002\u0002\u14c1\u14c2\t\u0018\u0002\u0002\u14c2\u14c5\t\u0018", + "\u0002\u0002\u14c3\u14c5\n\u0019\u0002\u0002\u14c4\u14b3\u0003\u0002", + "\u0002\u0002\u14c4\u14b5\u0003\u0002\u0002\u0002\u14c4\u14ba\u0003\u0002", + "\u0002\u0002\u14c4\u14c3\u0003\u0002\u0002\u0002\u14c5\u14c8\u0003\u0002", + "\u0002\u0002\u14c6\u14c8\n\u001a\u0002\u0002\u14c7\u14b0\u0003\u0002", + "\u0002\u0002\u14c7\u14b2\u0003\u0002\u0002\u0002\u14c7\u14c6\u0003\u0002", + "\u0002\u0002\u14c8\u14cb\u0003\u0002\u0002\u0002\u14c9\u14c7\u0003\u0002", + "\u0002\u0002\u14c9\u14ca\u0003\u0002\u0002\u0002\u14ca\u0464\u0003\u0002", + "\u0002\u0002\u14cb\u14c9\u0003\u0002\u0002\u0002\u14cc\u14cd\u0005\u0469", + "\u0233\u0002\u14cd\u14ce\u0007)\u0002\u0002\u14ce\u14cf\u0003\u0002", + "\u0002\u0002\u14cf\u14d0\b\u0231\u000b\u0002\u14d0\u0466\u0003\u0002", + "\u0002\u0002\u14d1\u14d3\u0005\u0469\u0233\u0002\u14d2\u14d4\u0007^", + "\u0002\u0002\u14d3\u14d2\u0003\u0002\u0002\u0002\u14d3\u14d4\u0003\u0002", + "\u0002\u0002\u14d4\u14d5\u0003\u0002\u0002\u0002\u14d5\u14d6\u0007\u0002", + "\u0002\u0003\u14d6\u0468\u0003\u0002\u0002\u0002\u14d7\u14d8\u0007)", + "\u0002\u0002\u14d8\u14dd\u0007)\u0002\u0002\u14d9\u14da\u0007^\u0002", + "\u0002\u14da\u14dd\u000b\u0002\u0002\u0002\u14db\u14dd\n\u001a\u0002", + "\u0002\u14dc\u14d7\u0003\u0002\u0002\u0002\u14dc\u14d9\u0003\u0002\u0002", + "\u0002\u14dc\u14db\u0003\u0002\u0002\u0002\u14dd\u14e0\u0003\u0002\u0002", + "\u0002\u14de\u14dc\u0003\u0002\u0002\u0002\u14de\u14df\u0003\u0002\u0002", + "\u0002\u14df\u046a\u0003\u0002\u0002\u0002\u14e0\u14de\u0003\u0002\u0002", + "\u0002\u14e1\u14e2\u0005\u044f\u0226\u0002\u14e2\u14e3\u0003\u0002\u0002", + "\u0002\u14e3\u14e4\b\u0234\f\u0002\u14e4\u14e5\b\u0234\t\u0002\u14e5", + "\u046c\u0003\u0002\u0002\u0002\u14e6\u14e7\u0005\u0451\u0227\u0002\u14e7", + "\u14e8\u0003\u0002\u0002\u0002\u14e8\u14e9\b\u0235\r\u0002\u14e9\u14ea", + "\b\u0235\t\u0002\u14ea\u14eb\b\u0235\u000e\u0002\u14eb\u046e\u0003\u0002", + "\u0002\u0002\u14ec\u14ed\b\u0236\u000f\u0002\u14ed\u14ee\u0003\u0002", + "\u0002\u0002\u14ee\u14ef\b\u0236\u0010\u0002\u14ef\u14f0\b\u0236\u0011", + "\u0002\u14f0\u0470\u0003\u0002\u0002\u0002\u14f1\u14f2\u0005\u044f\u0226", + "\u0002\u14f2\u14f3\u0003\u0002\u0002\u0002\u14f3\u14f4\b\u0237\f\u0002", + "\u14f4\u14f5\b\u0237\t\u0002\u14f5\u0472\u0003\u0002\u0002\u0002\u14f6", + "\u14f7\u0005\u0451\u0227\u0002\u14f7\u14f8\u0003\u0002\u0002\u0002\u14f8", + "\u14f9\b\u0238\r\u0002\u14f9\u14fa\b\u0238\t\u0002\u14fa\u0474\u0003", + "\u0002\u0002\u0002\u14fb\u14fc\u0007)\u0002\u0002\u14fc\u14fd\u0003", + "\u0002\u0002\u0002\u14fd\u14fe\b\u0239\u0004\u0002\u14fe\u14ff\b\u0239", + "\u0012\u0002\u14ff\u0476\u0003\u0002\u0002\u0002\u1500\u1501\b\u023a", + "\u0013\u0002\u1501\u1502\u0003\u0002\u0002\u0002\u1502\u1503\b\u023a", + "\u0010\u0002\u1503\u1504\b\u023a\u0011\u0002\u1504\u0478\u0003\u0002", + "\u0002\u0002\u1505\u1507\n\u001b\u0002\u0002\u1506\u1505\u0003\u0002", + "\u0002\u0002\u1507\u1508\u0003\u0002\u0002\u0002\u1508\u1506\u0003\u0002", + "\u0002\u0002\u1508\u1509\u0003\u0002\u0002\u0002\u1509\u1512\u0003\u0002", + "\u0002\u0002\u150a\u150e\u0007&\u0002\u0002\u150b\u150d\n\u001b\u0002", + "\u0002\u150c\u150b\u0003\u0002\u0002\u0002\u150d\u1510\u0003\u0002\u0002", + "\u0002\u150e\u150c\u0003\u0002\u0002\u0002\u150e\u150f\u0003\u0002\u0002", + "\u0002\u150f\u1512\u0003\u0002\u0002\u0002\u1510\u150e\u0003\u0002\u0002", + "\u0002\u1511\u1506\u0003\u0002\u0002\u0002\u1511\u150a\u0003\u0002\u0002", + "\u0002\u1512\u047a\u0003\u0002\u0002\u0002\u1513\u1515\u0007&\u0002", + "\u0002\u1514\u1516\u0005\u0431\u0217\u0002\u1515\u1514\u0003\u0002\u0002", + "\u0002\u1515\u1516\u0003\u0002\u0002\u0002\u1516\u1517\u0003\u0002\u0002", + "\u0002\u1517\u1518\u0007&\u0002\u0002\u1518\u1519\u0003\u0002\u0002", + "\u0002\u1519\u151a\u0006\u023c\n\u0002\u151a\u151b\b\u023c\u0014\u0002", + "\u151b\u151c\u0003\u0002\u0002\u0002\u151c\u151d\b\u023c\u0011\u0002", + "\u151d\u047c\u0003\u0002\u0002\u0002P\u0002\u0003\u0004\u0005\u0006", + "\u04c0\u04c6\u04c8\u04cd\u04d1\u04d3\u04d6\u04df\u04e1\u04e6\u04eb\u04ed", + "\u134b\u1354\u1358\u135c\u1365\u1367\u1371\u1373\u138d\u138f\u13a1\u13ac", + "\u13b7\u13c8\u13dc\u13e0\u13e3\u13e9\u13ec\u13f1\u13f5\u13fa\u1401\u140c", + "\u140e\u1416\u141c\u141f\u1429\u1434\u143c\u1442\u1445\u1447\u144d\u145b", + "\u1463\u1469\u146c\u146e\u1470\u1476\u147b\u1480\u1484\u148e\u1492\u1494", + "\u149b\u149e\u14ac\u14c4\u14c7\u14c9\u14d3\u14dc\u14de\u1508\u150e\u1511", + "\u1515\u0015\u0003\u001e\u0002\t\u001f\u0002\u0005\u0002\u0002\u0007", + "\u0003\u0002\u0003\u0216\u0003\u0007\u0006\u0002\u0003\u0221\u0004\u0002", + "\u0003\u0002\u0003\u022a\u0005\u0004\u0004\u0002\t\u021d\u0002\t\u021e", + "\u0002\u0004\u0005\u0002\u0003\u0236\u0006\b\u0002\u0002\u0006\u0002", + "\u0002\u0004\u0003\u0002\u0003\u023a\u0007\u0003\u023c\b"].join(""); + + +var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN); + +var decisionsToDFA = atn.decisionToState.map( function(ds, index) { return new antlr4.dfa.DFA(ds, index); }); + +function PostgreSQLLexer(input) { + PostgreSQLLexerBase.call(this, input); + this._interp = new antlr4.atn.LexerATNSimulator(this, atn, decisionsToDFA, new antlr4.PredictionContextCache()); + + /* This field stores the tags which are used to detect the end of a dollar-quoted string literal. + */ + + return this; +} + +PostgreSQLLexer.prototype = Object.create(PostgreSQLLexerBase.prototype); +PostgreSQLLexer.prototype.constructor = PostgreSQLLexer; + +Object.defineProperty(PostgreSQLLexer.prototype, "atn", { + get : function() { + return atn; + } +}); + +PostgreSQLLexer.EOF = antlr4.Token.EOF; +PostgreSQLLexer.Dollar = 1; +PostgreSQLLexer.OPEN_PAREN = 2; +PostgreSQLLexer.CLOSE_PAREN = 3; +PostgreSQLLexer.OPEN_BRACKET = 4; +PostgreSQLLexer.CLOSE_BRACKET = 5; +PostgreSQLLexer.COMMA = 6; +PostgreSQLLexer.SEMI = 7; +PostgreSQLLexer.COLON = 8; +PostgreSQLLexer.STAR = 9; +PostgreSQLLexer.EQUAL = 10; +PostgreSQLLexer.DOT = 11; +PostgreSQLLexer.PLUS = 12; +PostgreSQLLexer.MINUS = 13; +PostgreSQLLexer.SLASH = 14; +PostgreSQLLexer.CARET = 15; +PostgreSQLLexer.LT = 16; +PostgreSQLLexer.GT = 17; +PostgreSQLLexer.LESS_LESS = 18; +PostgreSQLLexer.GREATER_GREATER = 19; +PostgreSQLLexer.COLON_EQUALS = 20; +PostgreSQLLexer.LESS_EQUALS = 21; +PostgreSQLLexer.EQUALS_GREATER = 22; +PostgreSQLLexer.GREATER_EQUALS = 23; +PostgreSQLLexer.DOT_DOT = 24; +PostgreSQLLexer.NOT_EQUALS = 25; +PostgreSQLLexer.TYPECAST = 26; +PostgreSQLLexer.PERCENT = 27; +PostgreSQLLexer.PARAM = 28; +PostgreSQLLexer.Operator = 29; +PostgreSQLLexer.ALL = 30; +PostgreSQLLexer.ANALYSE = 31; +PostgreSQLLexer.ANALYZE = 32; +PostgreSQLLexer.AND = 33; +PostgreSQLLexer.ANY = 34; +PostgreSQLLexer.ARRAY = 35; +PostgreSQLLexer.AS = 36; +PostgreSQLLexer.ASC = 37; +PostgreSQLLexer.ASYMMETRIC = 38; +PostgreSQLLexer.BOTH = 39; +PostgreSQLLexer.CASE = 40; +PostgreSQLLexer.CAST = 41; +PostgreSQLLexer.CHECK = 42; +PostgreSQLLexer.COLLATE = 43; +PostgreSQLLexer.COLUMN = 44; +PostgreSQLLexer.CONSTRAINT = 45; +PostgreSQLLexer.CREATE = 46; +PostgreSQLLexer.CURRENT_CATALOG = 47; +PostgreSQLLexer.CURRENT_DATE = 48; +PostgreSQLLexer.CURRENT_ROLE = 49; +PostgreSQLLexer.CURRENT_TIME = 50; +PostgreSQLLexer.CURRENT_TIMESTAMP = 51; +PostgreSQLLexer.CURRENT_USER = 52; +PostgreSQLLexer.DEFAULT = 53; +PostgreSQLLexer.DEFERRABLE = 54; +PostgreSQLLexer.DESC = 55; +PostgreSQLLexer.DISTINCT = 56; +PostgreSQLLexer.DO = 57; +PostgreSQLLexer.ELSE = 58; +PostgreSQLLexer.EXCEPT = 59; +PostgreSQLLexer.FALSE_P = 60; +PostgreSQLLexer.FETCH = 61; +PostgreSQLLexer.FOR = 62; +PostgreSQLLexer.FOREIGN = 63; +PostgreSQLLexer.FROM = 64; +PostgreSQLLexer.GRANT = 65; +PostgreSQLLexer.GROUP_P = 66; +PostgreSQLLexer.HAVING = 67; +PostgreSQLLexer.IN_P = 68; +PostgreSQLLexer.INITIALLY = 69; +PostgreSQLLexer.INTERSECT = 70; +PostgreSQLLexer.INTO = 71; +PostgreSQLLexer.LATERAL_P = 72; +PostgreSQLLexer.LEADING = 73; +PostgreSQLLexer.LIMIT = 74; +PostgreSQLLexer.LOCALTIME = 75; +PostgreSQLLexer.LOCALTIMESTAMP = 76; +PostgreSQLLexer.NOT = 77; +PostgreSQLLexer.NULL_P = 78; +PostgreSQLLexer.OFFSET = 79; +PostgreSQLLexer.ON = 80; +PostgreSQLLexer.ONLY = 81; +PostgreSQLLexer.OR = 82; +PostgreSQLLexer.ORDER = 83; +PostgreSQLLexer.PLACING = 84; +PostgreSQLLexer.PRIMARY = 85; +PostgreSQLLexer.REFERENCES = 86; +PostgreSQLLexer.RETURNING = 87; +PostgreSQLLexer.SELECT = 88; +PostgreSQLLexer.SESSION_USER = 89; +PostgreSQLLexer.SOME = 90; +PostgreSQLLexer.SYMMETRIC = 91; +PostgreSQLLexer.TABLE = 92; +PostgreSQLLexer.THEN = 93; +PostgreSQLLexer.TO = 94; +PostgreSQLLexer.TRAILING = 95; +PostgreSQLLexer.TRUE_P = 96; +PostgreSQLLexer.UNION = 97; +PostgreSQLLexer.UNIQUE = 98; +PostgreSQLLexer.USER = 99; +PostgreSQLLexer.USING = 100; +PostgreSQLLexer.VARIADIC = 101; +PostgreSQLLexer.WHEN = 102; +PostgreSQLLexer.WHERE = 103; +PostgreSQLLexer.WINDOW = 104; +PostgreSQLLexer.WITH = 105; +PostgreSQLLexer.AUTHORIZATION = 106; +PostgreSQLLexer.BINARY = 107; +PostgreSQLLexer.COLLATION = 108; +PostgreSQLLexer.CONCURRENTLY = 109; +PostgreSQLLexer.CROSS = 110; +PostgreSQLLexer.CURRENT_SCHEMA = 111; +PostgreSQLLexer.FREEZE = 112; +PostgreSQLLexer.FULL = 113; +PostgreSQLLexer.ILIKE = 114; +PostgreSQLLexer.INNER_P = 115; +PostgreSQLLexer.IS = 116; +PostgreSQLLexer.ISNULL = 117; +PostgreSQLLexer.JOIN = 118; +PostgreSQLLexer.LEFT = 119; +PostgreSQLLexer.LIKE = 120; +PostgreSQLLexer.NATURAL = 121; +PostgreSQLLexer.NOTNULL = 122; +PostgreSQLLexer.OUTER_P = 123; +PostgreSQLLexer.OVER = 124; +PostgreSQLLexer.OVERLAPS = 125; +PostgreSQLLexer.RIGHT = 126; +PostgreSQLLexer.SIMILAR = 127; +PostgreSQLLexer.VERBOSE = 128; +PostgreSQLLexer.ABORT_P = 129; +PostgreSQLLexer.ABSOLUTE_P = 130; +PostgreSQLLexer.ACCESS = 131; +PostgreSQLLexer.ACTION = 132; +PostgreSQLLexer.ADD_P = 133; +PostgreSQLLexer.ADMIN = 134; +PostgreSQLLexer.AFTER = 135; +PostgreSQLLexer.AGGREGATE = 136; +PostgreSQLLexer.ALSO = 137; +PostgreSQLLexer.ALTER = 138; +PostgreSQLLexer.ALWAYS = 139; +PostgreSQLLexer.ASSERTION = 140; +PostgreSQLLexer.ASSIGNMENT = 141; +PostgreSQLLexer.AT = 142; +PostgreSQLLexer.ATTRIBUTE = 143; +PostgreSQLLexer.BACKWARD = 144; +PostgreSQLLexer.BEFORE = 145; +PostgreSQLLexer.BEGIN_P = 146; +PostgreSQLLexer.BY = 147; +PostgreSQLLexer.CACHE = 148; +PostgreSQLLexer.CALLED = 149; +PostgreSQLLexer.CASCADE = 150; +PostgreSQLLexer.CASCADED = 151; +PostgreSQLLexer.CATALOG = 152; +PostgreSQLLexer.CHAIN = 153; +PostgreSQLLexer.CHARACTERISTICS = 154; +PostgreSQLLexer.CHECKPOINT = 155; +PostgreSQLLexer.CLASS = 156; +PostgreSQLLexer.CLOSE = 157; +PostgreSQLLexer.CLUSTER = 158; +PostgreSQLLexer.COMMENT = 159; +PostgreSQLLexer.COMMENTS = 160; +PostgreSQLLexer.COMMIT = 161; +PostgreSQLLexer.COMMITTED = 162; +PostgreSQLLexer.CONFIGURATION = 163; +PostgreSQLLexer.CONNECTION = 164; +PostgreSQLLexer.CONSTRAINTS = 165; +PostgreSQLLexer.CONTENT_P = 166; +PostgreSQLLexer.CONTINUE_P = 167; +PostgreSQLLexer.CONVERSION_P = 168; +PostgreSQLLexer.COPY = 169; +PostgreSQLLexer.COST = 170; +PostgreSQLLexer.CSV = 171; +PostgreSQLLexer.CURSOR = 172; +PostgreSQLLexer.CYCLE = 173; +PostgreSQLLexer.DATA_P = 174; +PostgreSQLLexer.DATABASE = 175; +PostgreSQLLexer.DAY_P = 176; +PostgreSQLLexer.DEALLOCATE = 177; +PostgreSQLLexer.DECLARE = 178; +PostgreSQLLexer.DEFAULTS = 179; +PostgreSQLLexer.DEFERRED = 180; +PostgreSQLLexer.DEFINER = 181; +PostgreSQLLexer.DELETE_P = 182; +PostgreSQLLexer.DELIMITER = 183; +PostgreSQLLexer.DELIMITERS = 184; +PostgreSQLLexer.DICTIONARY = 185; +PostgreSQLLexer.DISABLE_P = 186; +PostgreSQLLexer.DISCARD = 187; +PostgreSQLLexer.DOCUMENT_P = 188; +PostgreSQLLexer.DOMAIN_P = 189; +PostgreSQLLexer.DOUBLE_P = 190; +PostgreSQLLexer.DROP = 191; +PostgreSQLLexer.EACH = 192; +PostgreSQLLexer.ENABLE_P = 193; +PostgreSQLLexer.ENCODING = 194; +PostgreSQLLexer.ENCRYPTED = 195; +PostgreSQLLexer.ENUM_P = 196; +PostgreSQLLexer.ESCAPE = 197; +PostgreSQLLexer.EVENT = 198; +PostgreSQLLexer.EXCLUDE = 199; +PostgreSQLLexer.EXCLUDING = 200; +PostgreSQLLexer.EXCLUSIVE = 201; +PostgreSQLLexer.EXECUTE = 202; +PostgreSQLLexer.EXPLAIN = 203; +PostgreSQLLexer.EXTENSION = 204; +PostgreSQLLexer.EXTERNAL = 205; +PostgreSQLLexer.FAMILY = 206; +PostgreSQLLexer.FIRST_P = 207; +PostgreSQLLexer.FOLLOWING = 208; +PostgreSQLLexer.FORCE = 209; +PostgreSQLLexer.FORWARD = 210; +PostgreSQLLexer.FUNCTION = 211; +PostgreSQLLexer.FUNCTIONS = 212; +PostgreSQLLexer.GLOBAL = 213; +PostgreSQLLexer.GRANTED = 214; +PostgreSQLLexer.HANDLER = 215; +PostgreSQLLexer.HEADER_P = 216; +PostgreSQLLexer.HOLD = 217; +PostgreSQLLexer.HOUR_P = 218; +PostgreSQLLexer.IDENTITY_P = 219; +PostgreSQLLexer.IF_P = 220; +PostgreSQLLexer.IMMEDIATE = 221; +PostgreSQLLexer.IMMUTABLE = 222; +PostgreSQLLexer.IMPLICIT_P = 223; +PostgreSQLLexer.INCLUDING = 224; +PostgreSQLLexer.INCREMENT = 225; +PostgreSQLLexer.INDEX = 226; +PostgreSQLLexer.INDEXES = 227; +PostgreSQLLexer.INHERIT = 228; +PostgreSQLLexer.INHERITS = 229; +PostgreSQLLexer.INLINE_P = 230; +PostgreSQLLexer.INSENSITIVE = 231; +PostgreSQLLexer.INSERT = 232; +PostgreSQLLexer.INSTEAD = 233; +PostgreSQLLexer.INVOKER = 234; +PostgreSQLLexer.ISOLATION = 235; +PostgreSQLLexer.KEY = 236; +PostgreSQLLexer.LABEL = 237; +PostgreSQLLexer.LANGUAGE = 238; +PostgreSQLLexer.LARGE_P = 239; +PostgreSQLLexer.LAST_P = 240; +PostgreSQLLexer.LEAKPROOF = 241; +PostgreSQLLexer.LEVEL = 242; +PostgreSQLLexer.LISTEN = 243; +PostgreSQLLexer.LOAD = 244; +PostgreSQLLexer.LOCAL = 245; +PostgreSQLLexer.LOCATION = 246; +PostgreSQLLexer.LOCK_P = 247; +PostgreSQLLexer.MAPPING = 248; +PostgreSQLLexer.MATCH = 249; +PostgreSQLLexer.MATERIALIZED = 250; +PostgreSQLLexer.MAXVALUE = 251; +PostgreSQLLexer.MINUTE_P = 252; +PostgreSQLLexer.MINVALUE = 253; +PostgreSQLLexer.MODE = 254; +PostgreSQLLexer.MONTH_P = 255; +PostgreSQLLexer.MOVE = 256; +PostgreSQLLexer.NAME_P = 257; +PostgreSQLLexer.NAMES = 258; +PostgreSQLLexer.NEXT = 259; +PostgreSQLLexer.NO = 260; +PostgreSQLLexer.NOTHING = 261; +PostgreSQLLexer.NOTIFY = 262; +PostgreSQLLexer.NOWAIT = 263; +PostgreSQLLexer.NULLS_P = 264; +PostgreSQLLexer.OBJECT_P = 265; +PostgreSQLLexer.OF = 266; +PostgreSQLLexer.OFF = 267; +PostgreSQLLexer.OIDS = 268; +PostgreSQLLexer.OPERATOR = 269; +PostgreSQLLexer.OPTION = 270; +PostgreSQLLexer.OPTIONS = 271; +PostgreSQLLexer.OWNED = 272; +PostgreSQLLexer.OWNER = 273; +PostgreSQLLexer.PARSER = 274; +PostgreSQLLexer.PARTIAL = 275; +PostgreSQLLexer.PARTITION = 276; +PostgreSQLLexer.PASSING = 277; +PostgreSQLLexer.PASSWORD = 278; +PostgreSQLLexer.PLANS = 279; +PostgreSQLLexer.PRECEDING = 280; +PostgreSQLLexer.PREPARE = 281; +PostgreSQLLexer.PREPARED = 282; +PostgreSQLLexer.PRESERVE = 283; +PostgreSQLLexer.PRIOR = 284; +PostgreSQLLexer.PRIVILEGES = 285; +PostgreSQLLexer.PROCEDURAL = 286; +PostgreSQLLexer.PROCEDURE = 287; +PostgreSQLLexer.PROGRAM = 288; +PostgreSQLLexer.QUOTE = 289; +PostgreSQLLexer.RANGE = 290; +PostgreSQLLexer.READ = 291; +PostgreSQLLexer.REASSIGN = 292; +PostgreSQLLexer.RECHECK = 293; +PostgreSQLLexer.RECURSIVE = 294; +PostgreSQLLexer.REF = 295; +PostgreSQLLexer.REFRESH = 296; +PostgreSQLLexer.REINDEX = 297; +PostgreSQLLexer.RELATIVE_P = 298; +PostgreSQLLexer.RELEASE = 299; +PostgreSQLLexer.RENAME = 300; +PostgreSQLLexer.REPEATABLE = 301; +PostgreSQLLexer.REPLACE = 302; +PostgreSQLLexer.REPLICA = 303; +PostgreSQLLexer.RESET = 304; +PostgreSQLLexer.RESTART = 305; +PostgreSQLLexer.RESTRICT = 306; +PostgreSQLLexer.RETURNS = 307; +PostgreSQLLexer.REVOKE = 308; +PostgreSQLLexer.ROLE = 309; +PostgreSQLLexer.ROLLBACK = 310; +PostgreSQLLexer.ROWS = 311; +PostgreSQLLexer.RULE = 312; +PostgreSQLLexer.SAVEPOINT = 313; +PostgreSQLLexer.SCHEMA = 314; +PostgreSQLLexer.SCROLL = 315; +PostgreSQLLexer.SEARCH = 316; +PostgreSQLLexer.SECOND_P = 317; +PostgreSQLLexer.SECURITY = 318; +PostgreSQLLexer.SEQUENCE = 319; +PostgreSQLLexer.SEQUENCES = 320; +PostgreSQLLexer.SERIALIZABLE = 321; +PostgreSQLLexer.SERVER = 322; +PostgreSQLLexer.SESSION = 323; +PostgreSQLLexer.SET = 324; +PostgreSQLLexer.SHARE = 325; +PostgreSQLLexer.SHOW = 326; +PostgreSQLLexer.SIMPLE = 327; +PostgreSQLLexer.SNAPSHOT = 328; +PostgreSQLLexer.STABLE = 329; +PostgreSQLLexer.STANDALONE_P = 330; +PostgreSQLLexer.START = 331; +PostgreSQLLexer.STATEMENT = 332; +PostgreSQLLexer.STATISTICS = 333; +PostgreSQLLexer.STDIN = 334; +PostgreSQLLexer.STDOUT = 335; +PostgreSQLLexer.STORAGE = 336; +PostgreSQLLexer.STRICT_P = 337; +PostgreSQLLexer.STRIP_P = 338; +PostgreSQLLexer.SYSID = 339; +PostgreSQLLexer.SYSTEM_P = 340; +PostgreSQLLexer.TABLES = 341; +PostgreSQLLexer.TABLESPACE = 342; +PostgreSQLLexer.TEMP = 343; +PostgreSQLLexer.TEMPLATE = 344; +PostgreSQLLexer.TEMPORARY = 345; +PostgreSQLLexer.TEXT_P = 346; +PostgreSQLLexer.TRANSACTION = 347; +PostgreSQLLexer.TRIGGER = 348; +PostgreSQLLexer.TRUNCATE = 349; +PostgreSQLLexer.TRUSTED = 350; +PostgreSQLLexer.TYPE_P = 351; +PostgreSQLLexer.TYPES_P = 352; +PostgreSQLLexer.UNBOUNDED = 353; +PostgreSQLLexer.UNCOMMITTED = 354; +PostgreSQLLexer.UNENCRYPTED = 355; +PostgreSQLLexer.UNKNOWN = 356; +PostgreSQLLexer.UNLISTEN = 357; +PostgreSQLLexer.UNLOGGED = 358; +PostgreSQLLexer.UNTIL = 359; +PostgreSQLLexer.UPDATE = 360; +PostgreSQLLexer.VACUUM = 361; +PostgreSQLLexer.VALID = 362; +PostgreSQLLexer.VALIDATE = 363; +PostgreSQLLexer.VALIDATOR = 364; +PostgreSQLLexer.VARYING = 365; +PostgreSQLLexer.VERSION_P = 366; +PostgreSQLLexer.VIEW = 367; +PostgreSQLLexer.VOLATILE = 368; +PostgreSQLLexer.WHITESPACE_P = 369; +PostgreSQLLexer.WITHOUT = 370; +PostgreSQLLexer.WORK = 371; +PostgreSQLLexer.WRAPPER = 372; +PostgreSQLLexer.WRITE = 373; +PostgreSQLLexer.XML_P = 374; +PostgreSQLLexer.YEAR_P = 375; +PostgreSQLLexer.YES_P = 376; +PostgreSQLLexer.ZONE = 377; +PostgreSQLLexer.BETWEEN = 378; +PostgreSQLLexer.BIGINT = 379; +PostgreSQLLexer.BIT = 380; +PostgreSQLLexer.BOOLEAN_P = 381; +PostgreSQLLexer.CHAR_P = 382; +PostgreSQLLexer.CHARACTER = 383; +PostgreSQLLexer.COALESCE = 384; +PostgreSQLLexer.DEC = 385; +PostgreSQLLexer.DECIMAL_P = 386; +PostgreSQLLexer.EXISTS = 387; +PostgreSQLLexer.EXTRACT = 388; +PostgreSQLLexer.FLOAT_P = 389; +PostgreSQLLexer.GREATEST = 390; +PostgreSQLLexer.INOUT = 391; +PostgreSQLLexer.INT_P = 392; +PostgreSQLLexer.INTEGER = 393; +PostgreSQLLexer.INTERVAL = 394; +PostgreSQLLexer.LEAST = 395; +PostgreSQLLexer.NATIONAL = 396; +PostgreSQLLexer.NCHAR = 397; +PostgreSQLLexer.NONE = 398; +PostgreSQLLexer.NULLIF = 399; +PostgreSQLLexer.NUMERIC = 400; +PostgreSQLLexer.OVERLAY = 401; +PostgreSQLLexer.POSITION = 402; +PostgreSQLLexer.PRECISION = 403; +PostgreSQLLexer.REAL = 404; +PostgreSQLLexer.ROW = 405; +PostgreSQLLexer.SETOF = 406; +PostgreSQLLexer.SMALLINT = 407; +PostgreSQLLexer.SUBSTRING = 408; +PostgreSQLLexer.TIME = 409; +PostgreSQLLexer.TIMESTAMP = 410; +PostgreSQLLexer.TREAT = 411; +PostgreSQLLexer.TRIM = 412; +PostgreSQLLexer.VALUES = 413; +PostgreSQLLexer.VARCHAR = 414; +PostgreSQLLexer.XMLATTRIBUTES = 415; +PostgreSQLLexer.XMLCONCAT = 416; +PostgreSQLLexer.XMLELEMENT = 417; +PostgreSQLLexer.XMLEXISTS = 418; +PostgreSQLLexer.XMLFOREST = 419; +PostgreSQLLexer.XMLPARSE = 420; +PostgreSQLLexer.XMLPI = 421; +PostgreSQLLexer.XMLROOT = 422; +PostgreSQLLexer.XMLSERIALIZE = 423; +PostgreSQLLexer.CALL = 424; +PostgreSQLLexer.CURRENT_P = 425; +PostgreSQLLexer.ATTACH = 426; +PostgreSQLLexer.DETACH = 427; +PostgreSQLLexer.EXPRESSION = 428; +PostgreSQLLexer.GENERATED = 429; +PostgreSQLLexer.LOGGED = 430; +PostgreSQLLexer.STORED = 431; +PostgreSQLLexer.INCLUDE = 432; +PostgreSQLLexer.ROUTINE = 433; +PostgreSQLLexer.TRANSFORM = 434; +PostgreSQLLexer.IMPORT_P = 435; +PostgreSQLLexer.POLICY = 436; +PostgreSQLLexer.METHOD = 437; +PostgreSQLLexer.REFERENCING = 438; +PostgreSQLLexer.NEW = 439; +PostgreSQLLexer.OLD = 440; +PostgreSQLLexer.VALUE_P = 441; +PostgreSQLLexer.SUBSCRIPTION = 442; +PostgreSQLLexer.PUBLICATION = 443; +PostgreSQLLexer.OUT_P = 444; +PostgreSQLLexer.END_P = 445; +PostgreSQLLexer.ROUTINES = 446; +PostgreSQLLexer.SCHEMAS = 447; +PostgreSQLLexer.PROCEDURES = 448; +PostgreSQLLexer.INPUT_P = 449; +PostgreSQLLexer.SUPPORT = 450; +PostgreSQLLexer.PARALLEL = 451; +PostgreSQLLexer.SQL_P = 452; +PostgreSQLLexer.DEPENDS = 453; +PostgreSQLLexer.OVERRIDING = 454; +PostgreSQLLexer.CONFLICT = 455; +PostgreSQLLexer.SKIP_P = 456; +PostgreSQLLexer.LOCKED = 457; +PostgreSQLLexer.TIES = 458; +PostgreSQLLexer.ROLLUP = 459; +PostgreSQLLexer.CUBE = 460; +PostgreSQLLexer.GROUPING = 461; +PostgreSQLLexer.SETS = 462; +PostgreSQLLexer.TABLESAMPLE = 463; +PostgreSQLLexer.ORDINALITY = 464; +PostgreSQLLexer.XMLTABLE = 465; +PostgreSQLLexer.COLUMNS = 466; +PostgreSQLLexer.XMLNAMESPACES = 467; +PostgreSQLLexer.ROWTYPE = 468; +PostgreSQLLexer.NORMALIZED = 469; +PostgreSQLLexer.WITHIN = 470; +PostgreSQLLexer.FILTER = 471; +PostgreSQLLexer.GROUPS = 472; +PostgreSQLLexer.OTHERS = 473; +PostgreSQLLexer.NFC = 474; +PostgreSQLLexer.NFD = 475; +PostgreSQLLexer.NFKC = 476; +PostgreSQLLexer.NFKD = 477; +PostgreSQLLexer.UESCAPE = 478; +PostgreSQLLexer.VIEWS = 479; +PostgreSQLLexer.NORMALIZE = 480; +PostgreSQLLexer.DUMP = 481; +PostgreSQLLexer.PRINT_STRICT_PARAMS = 482; +PostgreSQLLexer.VARIABLE_CONFLICT = 483; +PostgreSQLLexer.ERROR = 484; +PostgreSQLLexer.USE_VARIABLE = 485; +PostgreSQLLexer.USE_COLUMN = 486; +PostgreSQLLexer.ALIAS = 487; +PostgreSQLLexer.CONSTANT = 488; +PostgreSQLLexer.PERFORM = 489; +PostgreSQLLexer.GET = 490; +PostgreSQLLexer.DIAGNOSTICS = 491; +PostgreSQLLexer.STACKED = 492; +PostgreSQLLexer.ELSIF = 493; +PostgreSQLLexer.WHILE = 494; +PostgreSQLLexer.REVERSE = 495; +PostgreSQLLexer.FOREACH = 496; +PostgreSQLLexer.SLICE = 497; +PostgreSQLLexer.EXIT = 498; +PostgreSQLLexer.RETURN = 499; +PostgreSQLLexer.QUERY = 500; +PostgreSQLLexer.RAISE = 501; +PostgreSQLLexer.SQLSTATE = 502; +PostgreSQLLexer.DEBUG = 503; +PostgreSQLLexer.LOG = 504; +PostgreSQLLexer.INFO = 505; +PostgreSQLLexer.NOTICE = 506; +PostgreSQLLexer.WARNING = 507; +PostgreSQLLexer.EXCEPTION = 508; +PostgreSQLLexer.ASSERT = 509; +PostgreSQLLexer.LOOP = 510; +PostgreSQLLexer.OPEN = 511; +PostgreSQLLexer.Identifier = 512; +PostgreSQLLexer.QuotedIdentifier = 513; +PostgreSQLLexer.UnterminatedQuotedIdentifier = 514; +PostgreSQLLexer.InvalidQuotedIdentifier = 515; +PostgreSQLLexer.InvalidUnterminatedQuotedIdentifier = 516; +PostgreSQLLexer.UnicodeQuotedIdentifier = 517; +PostgreSQLLexer.UnterminatedUnicodeQuotedIdentifier = 518; +PostgreSQLLexer.InvalidUnicodeQuotedIdentifier = 519; +PostgreSQLLexer.InvalidUnterminatedUnicodeQuotedIdentifier = 520; +PostgreSQLLexer.StringConstant = 521; +PostgreSQLLexer.UnterminatedStringConstant = 522; +PostgreSQLLexer.UnicodeEscapeStringConstant = 523; +PostgreSQLLexer.UnterminatedUnicodeEscapeStringConstant = 524; +PostgreSQLLexer.BeginDollarStringConstant = 525; +PostgreSQLLexer.BinaryStringConstant = 526; +PostgreSQLLexer.UnterminatedBinaryStringConstant = 527; +PostgreSQLLexer.InvalidBinaryStringConstant = 528; +PostgreSQLLexer.InvalidUnterminatedBinaryStringConstant = 529; +PostgreSQLLexer.HexadecimalStringConstant = 530; +PostgreSQLLexer.UnterminatedHexadecimalStringConstant = 531; +PostgreSQLLexer.InvalidHexadecimalStringConstant = 532; +PostgreSQLLexer.InvalidUnterminatedHexadecimalStringConstant = 533; +PostgreSQLLexer.Integral = 534; +PostgreSQLLexer.NumericFail = 535; +PostgreSQLLexer.Numeric = 536; +PostgreSQLLexer.PLSQLVARIABLENAME = 537; +PostgreSQLLexer.PLSQLIDENTIFIER = 538; +PostgreSQLLexer.Whitespace = 539; +PostgreSQLLexer.Newline = 540; +PostgreSQLLexer.LineComment = 541; +PostgreSQLLexer.BlockComment = 542; +PostgreSQLLexer.UnterminatedBlockComment = 543; +PostgreSQLLexer.MetaCommand = 544; +PostgreSQLLexer.EndMetaCommand = 545; +PostgreSQLLexer.ErrorCharacter = 546; +PostgreSQLLexer.EscapeStringConstant = 547; +PostgreSQLLexer.UnterminatedEscapeStringConstant = 548; +PostgreSQLLexer.InvalidEscapeStringConstant = 549; +PostgreSQLLexer.InvalidUnterminatedEscapeStringConstant = 550; +PostgreSQLLexer.AfterEscapeStringConstantMode_NotContinued = 551; +PostgreSQLLexer.AfterEscapeStringConstantWithNewlineMode_NotContinued = 552; +PostgreSQLLexer.DollarText = 553; +PostgreSQLLexer.EndDollarStringConstant = 554; +PostgreSQLLexer.AfterEscapeStringConstantWithNewlineMode_Continued = 555; + +PostgreSQLLexer.EscapeStringConstantMode = 1; +PostgreSQLLexer.AfterEscapeStringConstantMode = 2; +PostgreSQLLexer.AfterEscapeStringConstantWithNewlineMode = 3; +PostgreSQLLexer.DollarQuotedStringMode = 4; + +PostgreSQLLexer.prototype.channelNames = [ "DEFAULT_TOKEN_CHANNEL", "HIDDEN" ]; + +PostgreSQLLexer.prototype.modeNames = [ "DEFAULT_MODE", "EscapeStringConstantMode", + "AfterEscapeStringConstantMode", + "AfterEscapeStringConstantWithNewlineMode", + "DollarQuotedStringMode" ]; + +PostgreSQLLexer.prototype.literalNames = [ null, "'$'", "'('", "')'", "'['", + "']'", "','", "';'", "':'", "'*'", + "'='", "'.'", "'+'", "'-'", "'/'", + "'^'", "'<'", "'>'", "'<<'", + "'>>'", "':='", "'<='", "'=>'", + "'>='", "'..'", "'<>'", "'::'", + "'%'", null, null, "'ALL'", "'ANALYSE'", + "'ANALYZE'", "'AND'", "'ANY'", + "'ARRAY'", "'AS'", "'ASC'", "'ASYMMETRIC'", + "'BOTH'", "'CASE'", "'CAST'", + "'CHECK'", "'COLLATE'", "'COLUMN'", + "'CONSTRAINT'", "'CREATE'", "'CURRENT_CATALOG'", + "'CURRENT_DATE'", "'CURRENT_ROLE'", + "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'CURRENT_USER'", "'DEFAULT'", + "'DEFERRABLE'", "'DESC'", "'DISTINCT'", + "'DO'", "'ELSE'", "'EXCEPT'", + "'FALSE'", "'FETCH'", "'FOR'", + "'FOREIGN'", "'FROM'", "'GRANT'", + "'GROUP'", "'HAVING'", "'IN'", + "'INITIALLY'", "'INTERSECT'", + "'INTO'", "'LATERAL'", "'LEADING'", + "'LIMIT'", "'LOCALTIME'", "'LOCALTIMESTAMP'", + "'NOT'", "'NULL'", "'OFFSET'", + "'ON'", "'ONLY'", "'OR'", "'ORDER'", + "'PLACING'", "'PRIMARY'", "'REFERENCES'", + "'RETURNING'", "'SELECT'", "'SESSION_USER'", + "'SOME'", "'SYMMETRIC'", "'TABLE'", + "'THEN'", "'TO'", "'TRAILING'", + "'TRUE'", "'UNION'", "'UNIQUE'", + "'USER'", "'USING'", "'VARIADIC'", + "'WHEN'", "'WHERE'", "'WINDOW'", + "'WITH'", "'AUTHORIZATION'", + "'BINARY'", "'COLLATION'", "'CONCURRENTLY'", + "'CROSS'", "'CURRENT_SCHEMA'", + "'FREEZE'", "'FULL'", "'ILIKE'", + "'INNER'", "'IS'", "'ISNULL'", + "'JOIN'", "'LEFT'", "'LIKE'", + "'NATURAL'", "'NOTNULL'", "'OUTER'", + "'OVER'", "'OVERLAPS'", "'RIGHT'", + "'SIMILAR'", "'VERBOSE'", "'ABORT'", + "'ABSOLUTE'", "'ACCESS'", "'ACTION'", + "'ADD'", "'ADMIN'", "'AFTER'", + "'AGGREGATE'", "'ALSO'", "'ALTER'", + "'ALWAYS'", "'ASSERTION'", "'ASSIGNMENT'", + "'AT'", "'ATTRIBUTE'", "'BACKWARD'", + "'BEFORE'", "'BEGIN'", "'BY'", + "'CACHE'", "'CALLED'", "'CASCADE'", + "'CASCADED'", "'CATALOG'", "'CHAIN'", + "'CHARACTERISTICS'", "'CHECKPOINT'", + "'CLASS'", "'CLOSE'", "'CLUSTER'", + "'COMMENT'", "'COMMENTS'", "'COMMIT'", + "'COMMITTED'", "'CONFIGURATION'", + "'CONNECTION'", "'CONSTRAINTS'", + "'CONTENT'", "'CONTINUE'", "'CONVERSION'", + "'COPY'", "'COST'", "'CSV'", + "'CURSOR'", "'CYCLE'", "'DATA'", + "'DATABASE'", "'DAY'", "'DEALLOCATE'", + "'DECLARE'", "'DEFAULTS'", "'DEFERRED'", + "'DEFINER'", "'DELETE'", "'DELIMITER'", + "'DELIMITERS'", "'DICTIONARY'", + "'DISABLE'", "'DISCARD'", "'DOCUMENT'", + "'DOMAIN'", "'DOUBLE'", "'DROP'", + "'EACH'", "'ENABLE'", "'ENCODING'", + "'ENCRYPTED'", "'ENUM'", "'ESCAPE'", + "'EVENT'", "'EXCLUDE'", "'EXCLUDING'", + "'EXCLUSIVE'", "'EXECUTE'", "'EXPLAIN'", + "'EXTENSION'", "'EXTERNAL'", + "'FAMILY'", "'FIRST'", "'FOLLOWING'", + "'FORCE'", "'FORWARD'", "'FUNCTION'", + "'FUNCTIONS'", "'GLOBAL'", "'GRANTED'", + "'HANDLER'", "'HEADER'", "'HOLD'", + "'HOUR'", "'IDENTITY'", "'IF'", + "'IMMEDIATE'", "'IMMUTABLE'", + "'IMPLICIT'", "'INCLUDING'", + "'INCREMENT'", "'INDEX'", "'INDEXES'", + "'INHERIT'", "'INHERITS'", "'INLINE'", + "'INSENSITIVE'", "'INSERT'", + "'INSTEAD'", "'INVOKER'", "'ISOLATION'", + "'KEY'", "'LABEL'", "'LANGUAGE'", + "'LARGE'", "'LAST'", "'LEAKPROOF'", + "'LEVEL'", "'LISTEN'", "'LOAD'", + "'LOCAL'", "'LOCATION'", "'LOCK'", + "'MAPPING'", "'MATCH'", "'MATERIALIZED'", + "'MAXVALUE'", "'MINUTE'", "'MINVALUE'", + "'MODE'", "'MONTH'", "'MOVE'", + "'NAME'", "'NAMES'", "'NEXT'", + "'NO'", "'NOTHING'", "'NOTIFY'", + "'NOWAIT'", "'NULLS'", "'OBJECT'", + "'OF'", "'OFF'", "'OIDS'", "'OPERATOR'", + "'OPTION'", "'OPTIONS'", "'OWNED'", + "'OWNER'", "'PARSER'", "'PARTIAL'", + "'PARTITION'", "'PASSING'", "'PASSWORD'", + "'PLANS'", "'PRECEDING'", "'PREPARE'", + "'PREPARED'", "'PRESERVE'", "'PRIOR'", + "'PRIVILEGES'", "'PROCEDURAL'", + "'PROCEDURE'", "'PROGRAM'", "'QUOTE'", + "'RANGE'", "'READ'", "'REASSIGN'", + "'RECHECK'", "'RECURSIVE'", "'REF'", + "'REFRESH'", "'REINDEX'", "'RELATIVE'", + "'RELEASE'", "'RENAME'", "'REPEATABLE'", + "'REPLACE'", "'REPLICA'", "'RESET'", + "'RESTART'", "'RESTRICT'", "'RETURNS'", + "'REVOKE'", "'ROLE'", "'ROLLBACK'", + "'ROWS'", "'RULE'", "'SAVEPOINT'", + "'SCHEMA'", "'SCROLL'", "'SEARCH'", + "'SECOND'", "'SECURITY'", "'SEQUENCE'", + "'SEQUENCES'", "'SERIALIZABLE'", + "'SERVER'", "'SESSION'", "'SET'", + "'SHARE'", "'SHOW'", "'SIMPLE'", + "'SNAPSHOT'", "'STABLE'", "'STANDALONE'", + "'START'", "'STATEMENT'", "'STATISTICS'", + "'STDIN'", "'STDOUT'", "'STORAGE'", + "'STRICT'", "'STRIP'", "'SYSID'", + "'SYSTEM'", "'TABLES'", "'TABLESPACE'", + "'TEMP'", "'TEMPLATE'", "'TEMPORARY'", + "'TEXT'", "'TRANSACTION'", "'TRIGGER'", + "'TRUNCATE'", "'TRUSTED'", "'TYPE'", + "'TYPES'", "'UNBOUNDED'", "'UNCOMMITTED'", + "'UNENCRYPTED'", "'UNKNOWN'", + "'UNLISTEN'", "'UNLOGGED'", "'UNTIL'", + "'UPDATE'", "'VACUUM'", "'VALID'", + "'VALIDATE'", "'VALIDATOR'", + "'VARYING'", "'VERSION'", "'VIEW'", + "'VOLATILE'", "'WHITESPACE'", + "'WITHOUT'", "'WORK'", "'WRAPPER'", + "'WRITE'", "'XML'", "'YEAR'", + "'YES'", "'ZONE'", "'BETWEEN'", + "'BIGINT'", "'BIT'", "'BOOLEAN'", + "'CHAR'", "'CHARACTER'", "'COALESCE'", + "'DEC'", "'DECIMAL'", "'EXISTS'", + "'EXTRACT'", "'FLOAT'", "'GREATEST'", + "'INOUT'", "'INT'", "'INTEGER'", + "'INTERVAL'", "'LEAST'", "'NATIONAL'", + "'NCHAR'", "'NONE'", "'NULLIF'", + "'NUMERIC'", "'OVERLAY'", "'POSITION'", + "'PRECISION'", "'REAL'", "'ROW'", + "'SETOF'", "'SMALLINT'", "'SUBSTRING'", + "'TIME'", "'TIMESTAMP'", "'TREAT'", + "'TRIM'", "'VALUES'", "'VARCHAR'", + "'XMLATTRIBUTES'", "'XMLCONCAT'", + "'XMLELEMENT'", "'XMLEXISTS'", + "'XMLFOREST'", "'XMLPARSE'", + "'XMLPI'", "'XMLROOT'", "'XMLSERIALIZE'", + "'CALL'", "'CURRENT'", "'ATTACH'", + "'DETACH'", "'EXPRESSION'", "'GENERATED'", + "'LOGGED'", "'STORED'", "'INCLUDE'", + "'ROUTINE'", "'TRANSFORM'", "'IMPORT'", + "'POLICY'", "'METHOD'", "'REFERENCING'", + "'NEW'", "'OLD'", "'VALUE'", + "'SUBSCRIPTION'", "'PUBLICATION'", + "'OUT'", "'END'", "'ROUTINES'", + "'SCHEMAS'", "'PROCEDURES'", + "'INPUT'", "'SUPPORT'", "'PARALLEL'", + "'SQL'", "'DEPENDS'", "'OVERRIDING'", + "'CONFLICT'", "'SKIP'", "'LOCKED'", + "'TIES'", "'ROLLUP'", "'CUBE'", + "'GROUPING'", "'SETS'", "'TABLESAMPLE'", + "'ORDINALITY'", "'XMLTABLE'", + "'COLUMNS'", "'XMLNAMESPACES'", + "'ROWTYPE'", "'NORMALIZED'", + "'WITHIN'", "'FILTER'", "'GROUPS'", + "'OTHERS'", "'NFC'", "'NFD'", + "'NFKC'", "'NFKD'", "'UESCAPE'", + "'VIEWS'", "'NORMALIZE'", "'DUMP'", + "'PRINT_STRICT_PARAMS'", "'VARIABLE_CONFLICT'", + "'ERROR'", "'USE_VARIABLE'", + "'USE_COLUMN'", "'ALIAS'", "'CONSTANT'", + "'PERFORM'", "'GET'", "'DIAGNOSTICS'", + "'STACKED'", "'ELSIF'", "'WHILE'", + "'REVERSE'", "'FOREACH'", "'SLICE'", + "'EXIT'", "'RETURN'", "'QUERY'", + "'RAISE'", "'SQLSTATE'", "'DEBUG'", + "'LOG'", "'INFO'", "'NOTICE'", + "'WARNING'", "'EXCEPTION'", "'ASSERT'", + "'LOOP'", "'OPEN'", null, null, + null, null, null, null, null, + null, null, null, null, null, + null, null, null, null, null, + null, null, null, null, null, + null, null, null, null, null, + null, null, null, null, null, + null, "'\\\\'", null, null, null, + null, null, null, null, null, + null, "'''" ]; + +PostgreSQLLexer.prototype.symbolicNames = [ null, "Dollar", "OPEN_PAREN", + "CLOSE_PAREN", "OPEN_BRACKET", + "CLOSE_BRACKET", "COMMA", "SEMI", + "COLON", "STAR", "EQUAL", "DOT", + "PLUS", "MINUS", "SLASH", "CARET", + "LT", "GT", "LESS_LESS", "GREATER_GREATER", + "COLON_EQUALS", "LESS_EQUALS", + "EQUALS_GREATER", "GREATER_EQUALS", + "DOT_DOT", "NOT_EQUALS", "TYPECAST", + "PERCENT", "PARAM", "Operator", + "ALL", "ANALYSE", "ANALYZE", + "AND", "ANY", "ARRAY", "AS", + "ASC", "ASYMMETRIC", "BOTH", + "CASE", "CAST", "CHECK", "COLLATE", + "COLUMN", "CONSTRAINT", "CREATE", + "CURRENT_CATALOG", "CURRENT_DATE", + "CURRENT_ROLE", "CURRENT_TIME", + "CURRENT_TIMESTAMP", "CURRENT_USER", + "DEFAULT", "DEFERRABLE", "DESC", + "DISTINCT", "DO", "ELSE", "EXCEPT", + "FALSE_P", "FETCH", "FOR", "FOREIGN", + "FROM", "GRANT", "GROUP_P", + "HAVING", "IN_P", "INITIALLY", + "INTERSECT", "INTO", "LATERAL_P", + "LEADING", "LIMIT", "LOCALTIME", + "LOCALTIMESTAMP", "NOT", "NULL_P", + "OFFSET", "ON", "ONLY", "OR", + "ORDER", "PLACING", "PRIMARY", + "REFERENCES", "RETURNING", "SELECT", + "SESSION_USER", "SOME", "SYMMETRIC", + "TABLE", "THEN", "TO", "TRAILING", + "TRUE_P", "UNION", "UNIQUE", + "USER", "USING", "VARIADIC", + "WHEN", "WHERE", "WINDOW", "WITH", + "AUTHORIZATION", "BINARY", "COLLATION", + "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", + "FREEZE", "FULL", "ILIKE", "INNER_P", + "IS", "ISNULL", "JOIN", "LEFT", + "LIKE", "NATURAL", "NOTNULL", + "OUTER_P", "OVER", "OVERLAPS", + "RIGHT", "SIMILAR", "VERBOSE", + "ABORT_P", "ABSOLUTE_P", "ACCESS", + "ACTION", "ADD_P", "ADMIN", + "AFTER", "AGGREGATE", "ALSO", + "ALTER", "ALWAYS", "ASSERTION", + "ASSIGNMENT", "AT", "ATTRIBUTE", + "BACKWARD", "BEFORE", "BEGIN_P", + "BY", "CACHE", "CALLED", "CASCADE", + "CASCADED", "CATALOG", "CHAIN", + "CHARACTERISTICS", "CHECKPOINT", + "CLASS", "CLOSE", "CLUSTER", + "COMMENT", "COMMENTS", "COMMIT", + "COMMITTED", "CONFIGURATION", + "CONNECTION", "CONSTRAINTS", + "CONTENT_P", "CONTINUE_P", "CONVERSION_P", + "COPY", "COST", "CSV", "CURSOR", + "CYCLE", "DATA_P", "DATABASE", + "DAY_P", "DEALLOCATE", "DECLARE", + "DEFAULTS", "DEFERRED", "DEFINER", + "DELETE_P", "DELIMITER", "DELIMITERS", + "DICTIONARY", "DISABLE_P", "DISCARD", + "DOCUMENT_P", "DOMAIN_P", "DOUBLE_P", + "DROP", "EACH", "ENABLE_P", + "ENCODING", "ENCRYPTED", "ENUM_P", + "ESCAPE", "EVENT", "EXCLUDE", + "EXCLUDING", "EXCLUSIVE", "EXECUTE", + "EXPLAIN", "EXTENSION", "EXTERNAL", + "FAMILY", "FIRST_P", "FOLLOWING", + "FORCE", "FORWARD", "FUNCTION", + "FUNCTIONS", "GLOBAL", "GRANTED", + "HANDLER", "HEADER_P", "HOLD", + "HOUR_P", "IDENTITY_P", "IF_P", + "IMMEDIATE", "IMMUTABLE", "IMPLICIT_P", + "INCLUDING", "INCREMENT", "INDEX", + "INDEXES", "INHERIT", "INHERITS", + "INLINE_P", "INSENSITIVE", "INSERT", + "INSTEAD", "INVOKER", "ISOLATION", + "KEY", "LABEL", "LANGUAGE", + "LARGE_P", "LAST_P", "LEAKPROOF", + "LEVEL", "LISTEN", "LOAD", "LOCAL", + "LOCATION", "LOCK_P", "MAPPING", + "MATCH", "MATERIALIZED", "MAXVALUE", + "MINUTE_P", "MINVALUE", "MODE", + "MONTH_P", "MOVE", "NAME_P", + "NAMES", "NEXT", "NO", "NOTHING", + "NOTIFY", "NOWAIT", "NULLS_P", + "OBJECT_P", "OF", "OFF", "OIDS", + "OPERATOR", "OPTION", "OPTIONS", + "OWNED", "OWNER", "PARSER", + "PARTIAL", "PARTITION", "PASSING", + "PASSWORD", "PLANS", "PRECEDING", + "PREPARE", "PREPARED", "PRESERVE", + "PRIOR", "PRIVILEGES", "PROCEDURAL", + "PROCEDURE", "PROGRAM", "QUOTE", + "RANGE", "READ", "REASSIGN", + "RECHECK", "RECURSIVE", "REF", + "REFRESH", "REINDEX", "RELATIVE_P", + "RELEASE", "RENAME", "REPEATABLE", + "REPLACE", "REPLICA", "RESET", + "RESTART", "RESTRICT", "RETURNS", + "REVOKE", "ROLE", "ROLLBACK", + "ROWS", "RULE", "SAVEPOINT", + "SCHEMA", "SCROLL", "SEARCH", + "SECOND_P", "SECURITY", "SEQUENCE", + "SEQUENCES", "SERIALIZABLE", + "SERVER", "SESSION", "SET", + "SHARE", "SHOW", "SIMPLE", "SNAPSHOT", + "STABLE", "STANDALONE_P", "START", + "STATEMENT", "STATISTICS", "STDIN", + "STDOUT", "STORAGE", "STRICT_P", + "STRIP_P", "SYSID", "SYSTEM_P", + "TABLES", "TABLESPACE", "TEMP", + "TEMPLATE", "TEMPORARY", "TEXT_P", + "TRANSACTION", "TRIGGER", "TRUNCATE", + "TRUSTED", "TYPE_P", "TYPES_P", + "UNBOUNDED", "UNCOMMITTED", + "UNENCRYPTED", "UNKNOWN", "UNLISTEN", + "UNLOGGED", "UNTIL", "UPDATE", + "VACUUM", "VALID", "VALIDATE", + "VALIDATOR", "VARYING", "VERSION_P", + "VIEW", "VOLATILE", "WHITESPACE_P", + "WITHOUT", "WORK", "WRAPPER", + "WRITE", "XML_P", "YEAR_P", + "YES_P", "ZONE", "BETWEEN", + "BIGINT", "BIT", "BOOLEAN_P", + "CHAR_P", "CHARACTER", "COALESCE", + "DEC", "DECIMAL_P", "EXISTS", + "EXTRACT", "FLOAT_P", "GREATEST", + "INOUT", "INT_P", "INTEGER", + "INTERVAL", "LEAST", "NATIONAL", + "NCHAR", "NONE", "NULLIF", "NUMERIC", + "OVERLAY", "POSITION", "PRECISION", + "REAL", "ROW", "SETOF", "SMALLINT", + "SUBSTRING", "TIME", "TIMESTAMP", + "TREAT", "TRIM", "VALUES", "VARCHAR", + "XMLATTRIBUTES", "XMLCONCAT", + "XMLELEMENT", "XMLEXISTS", "XMLFOREST", + "XMLPARSE", "XMLPI", "XMLROOT", + "XMLSERIALIZE", "CALL", "CURRENT_P", + "ATTACH", "DETACH", "EXPRESSION", + "GENERATED", "LOGGED", "STORED", + "INCLUDE", "ROUTINE", "TRANSFORM", + "IMPORT_P", "POLICY", "METHOD", + "REFERENCING", "NEW", "OLD", + "VALUE_P", "SUBSCRIPTION", "PUBLICATION", + "OUT_P", "END_P", "ROUTINES", + "SCHEMAS", "PROCEDURES", "INPUT_P", + "SUPPORT", "PARALLEL", "SQL_P", + "DEPENDS", "OVERRIDING", "CONFLICT", + "SKIP_P", "LOCKED", "TIES", + "ROLLUP", "CUBE", "GROUPING", + "SETS", "TABLESAMPLE", "ORDINALITY", + "XMLTABLE", "COLUMNS", "XMLNAMESPACES", + "ROWTYPE", "NORMALIZED", "WITHIN", + "FILTER", "GROUPS", "OTHERS", + "NFC", "NFD", "NFKC", "NFKD", + "UESCAPE", "VIEWS", "NORMALIZE", + "DUMP", "PRINT_STRICT_PARAMS", + "VARIABLE_CONFLICT", "ERROR", + "USE_VARIABLE", "USE_COLUMN", + "ALIAS", "CONSTANT", "PERFORM", + "GET", "DIAGNOSTICS", "STACKED", + "ELSIF", "WHILE", "REVERSE", + "FOREACH", "SLICE", "EXIT", + "RETURN", "QUERY", "RAISE", + "SQLSTATE", "DEBUG", "LOG", + "INFO", "NOTICE", "WARNING", + "EXCEPTION", "ASSERT", "LOOP", + "OPEN", "Identifier", "QuotedIdentifier", + "UnterminatedQuotedIdentifier", + "InvalidQuotedIdentifier", "InvalidUnterminatedQuotedIdentifier", + "UnicodeQuotedIdentifier", "UnterminatedUnicodeQuotedIdentifier", + "InvalidUnicodeQuotedIdentifier", + "InvalidUnterminatedUnicodeQuotedIdentifier", + "StringConstant", "UnterminatedStringConstant", + "UnicodeEscapeStringConstant", + "UnterminatedUnicodeEscapeStringConstant", + "BeginDollarStringConstant", + "BinaryStringConstant", "UnterminatedBinaryStringConstant", + "InvalidBinaryStringConstant", + "InvalidUnterminatedBinaryStringConstant", + "HexadecimalStringConstant", + "UnterminatedHexadecimalStringConstant", + "InvalidHexadecimalStringConstant", + "InvalidUnterminatedHexadecimalStringConstant", + "Integral", "NumericFail", "Numeric", + "PLSQLVARIABLENAME", "PLSQLIDENTIFIER", + "Whitespace", "Newline", "LineComment", + "BlockComment", "UnterminatedBlockComment", + "MetaCommand", "EndMetaCommand", + "ErrorCharacter", "EscapeStringConstant", + "UnterminatedEscapeStringConstant", + "InvalidEscapeStringConstant", + "InvalidUnterminatedEscapeStringConstant", + "AfterEscapeStringConstantMode_NotContinued", + "AfterEscapeStringConstantWithNewlineMode_NotContinued", + "DollarText", "EndDollarStringConstant", + "AfterEscapeStringConstantWithNewlineMode_Continued" ]; + +PostgreSQLLexer.prototype.ruleNames = [ "Dollar", "OPEN_PAREN", "CLOSE_PAREN", + "OPEN_BRACKET", "CLOSE_BRACKET", + "COMMA", "SEMI", "COLON", "STAR", + "EQUAL", "DOT", "PLUS", "MINUS", + "SLASH", "CARET", "LT", "GT", "LESS_LESS", + "GREATER_GREATER", "COLON_EQUALS", + "LESS_EQUALS", "EQUALS_GREATER", + "GREATER_EQUALS", "DOT_DOT", "NOT_EQUALS", + "TYPECAST", "PERCENT", "PARAM", + "Operator", "OperatorEndingWithPlusMinus", + "OperatorCharacter", "OperatorCharacterNotAllowPlusMinusAtEnd", + "OperatorCharacterAllowPlusMinusAtEnd", + "ALL", "ANALYSE", "ANALYZE", "AND", + "ANY", "ARRAY", "AS", "ASC", "ASYMMETRIC", + "BOTH", "CASE", "CAST", "CHECK", + "COLLATE", "COLUMN", "CONSTRAINT", + "CREATE", "CURRENT_CATALOG", "CURRENT_DATE", + "CURRENT_ROLE", "CURRENT_TIME", + "CURRENT_TIMESTAMP", "CURRENT_USER", + "DEFAULT", "DEFERRABLE", "DESC", + "DISTINCT", "DO", "ELSE", "EXCEPT", + "FALSE_P", "FETCH", "FOR", "FOREIGN", + "FROM", "GRANT", "GROUP_P", "HAVING", + "IN_P", "INITIALLY", "INTERSECT", + "INTO", "LATERAL_P", "LEADING", + "LIMIT", "LOCALTIME", "LOCALTIMESTAMP", + "NOT", "NULL_P", "OFFSET", "ON", + "ONLY", "OR", "ORDER", "PLACING", + "PRIMARY", "REFERENCES", "RETURNING", + "SELECT", "SESSION_USER", "SOME", + "SYMMETRIC", "TABLE", "THEN", "TO", + "TRAILING", "TRUE_P", "UNION", "UNIQUE", + "USER", "USING", "VARIADIC", "WHEN", + "WHERE", "WINDOW", "WITH", "AUTHORIZATION", + "BINARY", "COLLATION", "CONCURRENTLY", + "CROSS", "CURRENT_SCHEMA", "FREEZE", + "FULL", "ILIKE", "INNER_P", "IS", + "ISNULL", "JOIN", "LEFT", "LIKE", + "NATURAL", "NOTNULL", "OUTER_P", + "OVER", "OVERLAPS", "RIGHT", "SIMILAR", + "VERBOSE", "ABORT_P", "ABSOLUTE_P", + "ACCESS", "ACTION", "ADD_P", "ADMIN", + "AFTER", "AGGREGATE", "ALSO", "ALTER", + "ALWAYS", "ASSERTION", "ASSIGNMENT", + "AT", "ATTRIBUTE", "BACKWARD", "BEFORE", + "BEGIN_P", "BY", "CACHE", "CALLED", + "CASCADE", "CASCADED", "CATALOG", + "CHAIN", "CHARACTERISTICS", "CHECKPOINT", + "CLASS", "CLOSE", "CLUSTER", "COMMENT", + "COMMENTS", "COMMIT", "COMMITTED", + "CONFIGURATION", "CONNECTION", "CONSTRAINTS", + "CONTENT_P", "CONTINUE_P", "CONVERSION_P", + "COPY", "COST", "CSV", "CURSOR", + "CYCLE", "DATA_P", "DATABASE", "DAY_P", + "DEALLOCATE", "DECLARE", "DEFAULTS", + "DEFERRED", "DEFINER", "DELETE_P", + "DELIMITER", "DELIMITERS", "DICTIONARY", + "DISABLE_P", "DISCARD", "DOCUMENT_P", + "DOMAIN_P", "DOUBLE_P", "DROP", + "EACH", "ENABLE_P", "ENCODING", + "ENCRYPTED", "ENUM_P", "ESCAPE", + "EVENT", "EXCLUDE", "EXCLUDING", + "EXCLUSIVE", "EXECUTE", "EXPLAIN", + "EXTENSION", "EXTERNAL", "FAMILY", + "FIRST_P", "FOLLOWING", "FORCE", + "FORWARD", "FUNCTION", "FUNCTIONS", + "GLOBAL", "GRANTED", "HANDLER", + "HEADER_P", "HOLD", "HOUR_P", "IDENTITY_P", + "IF_P", "IMMEDIATE", "IMMUTABLE", + "IMPLICIT_P", "INCLUDING", "INCREMENT", + "INDEX", "INDEXES", "INHERIT", "INHERITS", + "INLINE_P", "INSENSITIVE", "INSERT", + "INSTEAD", "INVOKER", "ISOLATION", + "KEY", "LABEL", "LANGUAGE", "LARGE_P", + "LAST_P", "LEAKPROOF", "LEVEL", + "LISTEN", "LOAD", "LOCAL", "LOCATION", + "LOCK_P", "MAPPING", "MATCH", "MATERIALIZED", + "MAXVALUE", "MINUTE_P", "MINVALUE", + "MODE", "MONTH_P", "MOVE", "NAME_P", + "NAMES", "NEXT", "NO", "NOTHING", + "NOTIFY", "NOWAIT", "NULLS_P", "OBJECT_P", + "OF", "OFF", "OIDS", "OPERATOR", + "OPTION", "OPTIONS", "OWNED", "OWNER", + "PARSER", "PARTIAL", "PARTITION", + "PASSING", "PASSWORD", "PLANS", + "PRECEDING", "PREPARE", "PREPARED", + "PRESERVE", "PRIOR", "PRIVILEGES", + "PROCEDURAL", "PROCEDURE", "PROGRAM", + "QUOTE", "RANGE", "READ", "REASSIGN", + "RECHECK", "RECURSIVE", "REF", "REFRESH", + "REINDEX", "RELATIVE_P", "RELEASE", + "RENAME", "REPEATABLE", "REPLACE", + "REPLICA", "RESET", "RESTART", "RESTRICT", + "RETURNS", "REVOKE", "ROLE", "ROLLBACK", + "ROWS", "RULE", "SAVEPOINT", "SCHEMA", + "SCROLL", "SEARCH", "SECOND_P", + "SECURITY", "SEQUENCE", "SEQUENCES", + "SERIALIZABLE", "SERVER", "SESSION", + "SET", "SHARE", "SHOW", "SIMPLE", + "SNAPSHOT", "STABLE", "STANDALONE_P", + "START", "STATEMENT", "STATISTICS", + "STDIN", "STDOUT", "STORAGE", "STRICT_P", + "STRIP_P", "SYSID", "SYSTEM_P", + "TABLES", "TABLESPACE", "TEMP", + "TEMPLATE", "TEMPORARY", "TEXT_P", + "TRANSACTION", "TRIGGER", "TRUNCATE", + "TRUSTED", "TYPE_P", "TYPES_P", + "UNBOUNDED", "UNCOMMITTED", "UNENCRYPTED", + "UNKNOWN", "UNLISTEN", "UNLOGGED", + "UNTIL", "UPDATE", "VACUUM", "VALID", + "VALIDATE", "VALIDATOR", "VARYING", + "VERSION_P", "VIEW", "VOLATILE", + "WHITESPACE_P", "WITHOUT", "WORK", + "WRAPPER", "WRITE", "XML_P", "YEAR_P", + "YES_P", "ZONE", "BETWEEN", "BIGINT", + "BIT", "BOOLEAN_P", "CHAR_P", "CHARACTER", + "COALESCE", "DEC", "DECIMAL_P", + "EXISTS", "EXTRACT", "FLOAT_P", + "GREATEST", "INOUT", "INT_P", "INTEGER", + "INTERVAL", "LEAST", "NATIONAL", + "NCHAR", "NONE", "NULLIF", "NUMERIC", + "OVERLAY", "POSITION", "PRECISION", + "REAL", "ROW", "SETOF", "SMALLINT", + "SUBSTRING", "TIME", "TIMESTAMP", + "TREAT", "TRIM", "VALUES", "VARCHAR", + "XMLATTRIBUTES", "XMLCONCAT", "XMLELEMENT", + "XMLEXISTS", "XMLFOREST", "XMLPARSE", + "XMLPI", "XMLROOT", "XMLSERIALIZE", + "CALL", "CURRENT_P", "ATTACH", "DETACH", + "EXPRESSION", "GENERATED", "LOGGED", + "STORED", "INCLUDE", "ROUTINE", + "TRANSFORM", "IMPORT_P", "POLICY", + "METHOD", "REFERENCING", "NEW", + "OLD", "VALUE_P", "SUBSCRIPTION", + "PUBLICATION", "OUT_P", "END_P", + "ROUTINES", "SCHEMAS", "PROCEDURES", + "INPUT_P", "SUPPORT", "PARALLEL", + "SQL_P", "DEPENDS", "OVERRIDING", + "CONFLICT", "SKIP_P", "LOCKED", + "TIES", "ROLLUP", "CUBE", "GROUPING", + "SETS", "TABLESAMPLE", "ORDINALITY", + "XMLTABLE", "COLUMNS", "XMLNAMESPACES", + "ROWTYPE", "NORMALIZED", "WITHIN", + "FILTER", "GROUPS", "OTHERS", "NFC", + "NFD", "NFKC", "NFKD", "UESCAPE", + "VIEWS", "NORMALIZE", "DUMP", "PRINT_STRICT_PARAMS", + "VARIABLE_CONFLICT", "ERROR", "USE_VARIABLE", + "USE_COLUMN", "ALIAS", "CONSTANT", + "PERFORM", "GET", "DIAGNOSTICS", + "STACKED", "ELSIF", "WHILE", "REVERSE", + "FOREACH", "SLICE", "EXIT", "RETURN", + "QUERY", "RAISE", "SQLSTATE", "DEBUG", + "LOG", "INFO", "NOTICE", "WARNING", + "EXCEPTION", "ASSERT", "LOOP", "OPEN", + "Identifier", "IdentifierStartChar", + "IdentifierChar", "StrictIdentifierChar", + "QuotedIdentifier", "UnterminatedQuotedIdentifier", + "InvalidQuotedIdentifier", "InvalidUnterminatedQuotedIdentifier", + "UnicodeQuotedIdentifier", "UnterminatedUnicodeQuotedIdentifier", + "InvalidUnicodeQuotedIdentifier", + "InvalidUnterminatedUnicodeQuotedIdentifier", + "StringConstant", "UnterminatedStringConstant", + "BeginEscapeStringConstant", "UnicodeEscapeStringConstant", + "UnterminatedUnicodeEscapeStringConstant", + "BeginDollarStringConstant", "Tag", + "BinaryStringConstant", "UnterminatedBinaryStringConstant", + "InvalidBinaryStringConstant", "InvalidUnterminatedBinaryStringConstant", + "HexadecimalStringConstant", "UnterminatedHexadecimalStringConstant", + "InvalidHexadecimalStringConstant", + "InvalidUnterminatedHexadecimalStringConstant", + "Integral", "NumericFail", "Numeric", + "Digits", "PLSQLVARIABLENAME", "PLSQLIDENTIFIER", + "Whitespace", "Newline", "LineComment", + "BlockComment", "UnterminatedBlockComment", + "MetaCommand", "EndMetaCommand", + "ErrorCharacter", "EscapeStringConstant", + "UnterminatedEscapeStringConstant", + "EscapeStringText", "InvalidEscapeStringConstant", + "InvalidUnterminatedEscapeStringConstant", + "InvalidEscapeStringText", "AfterEscapeStringConstantMode_Whitespace", + "AfterEscapeStringConstantMode_Newline", + "AfterEscapeStringConstantMode_NotContinued", + "AfterEscapeStringConstantWithNewlineMode_Whitespace", + "AfterEscapeStringConstantWithNewlineMode_Newline", + "AfterEscapeStringConstantWithNewlineMode_Continued", + "AfterEscapeStringConstantWithNewlineMode_NotContinued", + "DollarText", "EndDollarStringConstant" ]; + +PostgreSQLLexer.prototype.grammarFileName = "PostgreSQLLexer.g4"; + +PostgreSQLLexer.prototype.action = function(localctx, ruleIndex, actionIndex) { + switch (ruleIndex) { + case 28: + this.Operator_action(localctx, actionIndex); + break; + case 532: + this.BeginDollarStringConstant_action(localctx, actionIndex); + break; + case 543: + this.NumericFail_action(localctx, actionIndex); + break; + case 552: + this.UnterminatedBlockComment_action(localctx, actionIndex); + break; + case 564: + this.AfterEscapeStringConstantMode_NotContinued_action(localctx, actionIndex); + break; + case 568: + this.AfterEscapeStringConstantWithNewlineMode_NotContinued_action(localctx, actionIndex); + break; + case 570: + this.EndDollarStringConstant_action(localctx, actionIndex); + break; + default: + throw "No registered action for:" + ruleIndex; + } +}; + + +PostgreSQLLexer.prototype.Operator_action = function(localctx , actionIndex) { + switch (actionIndex) { + case 0: + + this.HandleLessLessGreaterGreater(); + + break; + default: + throw "No registered action for:" + actionIndex; + } +}; + +PostgreSQLLexer.prototype.BeginDollarStringConstant_action = function(localctx , actionIndex) { + switch (actionIndex) { + case 1: + this.pushTag(); + break; + default: + throw "No registered action for:" + actionIndex; + } +}; + +PostgreSQLLexer.prototype.NumericFail_action = function(localctx , actionIndex) { + switch (actionIndex) { + case 2: + this.HandleNumericFail(); + break; + default: + throw "No registered action for:" + actionIndex; + } +}; + +PostgreSQLLexer.prototype.UnterminatedBlockComment_action = function(localctx , actionIndex) { + switch (actionIndex) { + case 3: + + this.UnterminatedBlockCommentDebugAssert(); + + break; + default: + throw "No registered action for:" + actionIndex; + } +}; + +PostgreSQLLexer.prototype.AfterEscapeStringConstantMode_NotContinued_action = function(localctx , actionIndex) { + switch (actionIndex) { + case 4: + break; + default: + throw "No registered action for:" + actionIndex; + } +}; + +PostgreSQLLexer.prototype.AfterEscapeStringConstantWithNewlineMode_NotContinued_action = function(localctx , actionIndex) { + switch (actionIndex) { + case 5: + break; + default: + throw "No registered action for:" + actionIndex; + } +}; + +PostgreSQLLexer.prototype.EndDollarStringConstant_action = function(localctx , actionIndex) { + switch (actionIndex) { + case 6: + this.popTag(); + break; + default: + throw "No registered action for:" + actionIndex; + } +}; +PostgreSQLLexer.prototype.sempred = function(localctx, ruleIndex, predIndex) { + switch (ruleIndex) { + case 28: + return this.Operator_sempred(localctx, predIndex); + case 29: + return this.OperatorEndingWithPlusMinus_sempred(localctx, predIndex); + case 516: + return this.IdentifierStartChar_sempred(localctx, predIndex); + case 570: + return this.EndDollarStringConstant_sempred(localctx, predIndex); + default: + throw "No registered predicate for:" + ruleIndex; + } +}; + +PostgreSQLLexer.prototype.Operator_sempred = function(localctx, predIndex) { + switch(predIndex) { + case 0: + return this.checkLA('-'); + case 1: + return this.checkLA('*'); + case 2: + return this.checkLA('*'); + default: + throw "No predicate with index:" + predIndex; + } +}; + +PostgreSQLLexer.prototype.OperatorEndingWithPlusMinus_sempred = function(localctx, predIndex) { + switch(predIndex) { + case 3: + return this.checkLA('-'); + case 4: + return this.checkLA('*'); + case 5: + return this.checkLA('-'); + default: + throw "No predicate with index:" + predIndex; + } +}; + +PostgreSQLLexer.prototype.IdentifierStartChar_sempred = function(localctx, predIndex) { + switch(predIndex) { + case 6: + return this.charIsLetter(); + case 7: + return + this.CheckIfUtf32Letter() + ; + default: + throw "No predicate with index:" + predIndex; + } +}; + +PostgreSQLLexer.prototype.EndDollarStringConstant_sempred = function(localctx, predIndex) { + switch(predIndex) { + case 8: + return this.isTag(); + default: + throw "No predicate with index:" + predIndex; + } +}; + + + +exports.PostgreSQLLexer = PostgreSQLLexer; + diff --git a/src/lib/pgsql/PostgreSQLLexer.tokens b/src/lib/pgsql/PostgreSQLLexer.tokens new file mode 100644 index 0000000..af0800f --- /dev/null +++ b/src/lib/pgsql/PostgreSQLLexer.tokens @@ -0,0 +1,1066 @@ +Dollar=1 +OPEN_PAREN=2 +CLOSE_PAREN=3 +OPEN_BRACKET=4 +CLOSE_BRACKET=5 +COMMA=6 +SEMI=7 +COLON=8 +STAR=9 +EQUAL=10 +DOT=11 +PLUS=12 +MINUS=13 +SLASH=14 +CARET=15 +LT=16 +GT=17 +LESS_LESS=18 +GREATER_GREATER=19 +COLON_EQUALS=20 +LESS_EQUALS=21 +EQUALS_GREATER=22 +GREATER_EQUALS=23 +DOT_DOT=24 +NOT_EQUALS=25 +TYPECAST=26 +PERCENT=27 +PARAM=28 +Operator=29 +ALL=30 +ANALYSE=31 +ANALYZE=32 +AND=33 +ANY=34 +ARRAY=35 +AS=36 +ASC=37 +ASYMMETRIC=38 +BOTH=39 +CASE=40 +CAST=41 +CHECK=42 +COLLATE=43 +COLUMN=44 +CONSTRAINT=45 +CREATE=46 +CURRENT_CATALOG=47 +CURRENT_DATE=48 +CURRENT_ROLE=49 +CURRENT_TIME=50 +CURRENT_TIMESTAMP=51 +CURRENT_USER=52 +DEFAULT=53 +DEFERRABLE=54 +DESC=55 +DISTINCT=56 +DO=57 +ELSE=58 +EXCEPT=59 +FALSE_P=60 +FETCH=61 +FOR=62 +FOREIGN=63 +FROM=64 +GRANT=65 +GROUP_P=66 +HAVING=67 +IN_P=68 +INITIALLY=69 +INTERSECT=70 +INTO=71 +LATERAL_P=72 +LEADING=73 +LIMIT=74 +LOCALTIME=75 +LOCALTIMESTAMP=76 +NOT=77 +NULL_P=78 +OFFSET=79 +ON=80 +ONLY=81 +OR=82 +ORDER=83 +PLACING=84 +PRIMARY=85 +REFERENCES=86 +RETURNING=87 +SELECT=88 +SESSION_USER=89 +SOME=90 +SYMMETRIC=91 +TABLE=92 +THEN=93 +TO=94 +TRAILING=95 +TRUE_P=96 +UNION=97 +UNIQUE=98 +USER=99 +USING=100 +VARIADIC=101 +WHEN=102 +WHERE=103 +WINDOW=104 +WITH=105 +AUTHORIZATION=106 +BINARY=107 +COLLATION=108 +CONCURRENTLY=109 +CROSS=110 +CURRENT_SCHEMA=111 +FREEZE=112 +FULL=113 +ILIKE=114 +INNER_P=115 +IS=116 +ISNULL=117 +JOIN=118 +LEFT=119 +LIKE=120 +NATURAL=121 +NOTNULL=122 +OUTER_P=123 +OVER=124 +OVERLAPS=125 +RIGHT=126 +SIMILAR=127 +VERBOSE=128 +ABORT_P=129 +ABSOLUTE_P=130 +ACCESS=131 +ACTION=132 +ADD_P=133 +ADMIN=134 +AFTER=135 +AGGREGATE=136 +ALSO=137 +ALTER=138 +ALWAYS=139 +ASSERTION=140 +ASSIGNMENT=141 +AT=142 +ATTRIBUTE=143 +BACKWARD=144 +BEFORE=145 +BEGIN_P=146 +BY=147 +CACHE=148 +CALLED=149 +CASCADE=150 +CASCADED=151 +CATALOG=152 +CHAIN=153 +CHARACTERISTICS=154 +CHECKPOINT=155 +CLASS=156 +CLOSE=157 +CLUSTER=158 +COMMENT=159 +COMMENTS=160 +COMMIT=161 +COMMITTED=162 +CONFIGURATION=163 +CONNECTION=164 +CONSTRAINTS=165 +CONTENT_P=166 +CONTINUE_P=167 +CONVERSION_P=168 +COPY=169 +COST=170 +CSV=171 +CURSOR=172 +CYCLE=173 +DATA_P=174 +DATABASE=175 +DAY_P=176 +DEALLOCATE=177 +DECLARE=178 +DEFAULTS=179 +DEFERRED=180 +DEFINER=181 +DELETE_P=182 +DELIMITER=183 +DELIMITERS=184 +DICTIONARY=185 +DISABLE_P=186 +DISCARD=187 +DOCUMENT_P=188 +DOMAIN_P=189 +DOUBLE_P=190 +DROP=191 +EACH=192 +ENABLE_P=193 +ENCODING=194 +ENCRYPTED=195 +ENUM_P=196 +ESCAPE=197 +EVENT=198 +EXCLUDE=199 +EXCLUDING=200 +EXCLUSIVE=201 +EXECUTE=202 +EXPLAIN=203 +EXTENSION=204 +EXTERNAL=205 +FAMILY=206 +FIRST_P=207 +FOLLOWING=208 +FORCE=209 +FORWARD=210 +FUNCTION=211 +FUNCTIONS=212 +GLOBAL=213 +GRANTED=214 +HANDLER=215 +HEADER_P=216 +HOLD=217 +HOUR_P=218 +IDENTITY_P=219 +IF_P=220 +IMMEDIATE=221 +IMMUTABLE=222 +IMPLICIT_P=223 +INCLUDING=224 +INCREMENT=225 +INDEX=226 +INDEXES=227 +INHERIT=228 +INHERITS=229 +INLINE_P=230 +INSENSITIVE=231 +INSERT=232 +INSTEAD=233 +INVOKER=234 +ISOLATION=235 +KEY=236 +LABEL=237 +LANGUAGE=238 +LARGE_P=239 +LAST_P=240 +LEAKPROOF=241 +LEVEL=242 +LISTEN=243 +LOAD=244 +LOCAL=245 +LOCATION=246 +LOCK_P=247 +MAPPING=248 +MATCH=249 +MATERIALIZED=250 +MAXVALUE=251 +MINUTE_P=252 +MINVALUE=253 +MODE=254 +MONTH_P=255 +MOVE=256 +NAME_P=257 +NAMES=258 +NEXT=259 +NO=260 +NOTHING=261 +NOTIFY=262 +NOWAIT=263 +NULLS_P=264 +OBJECT_P=265 +OF=266 +OFF=267 +OIDS=268 +OPERATOR=269 +OPTION=270 +OPTIONS=271 +OWNED=272 +OWNER=273 +PARSER=274 +PARTIAL=275 +PARTITION=276 +PASSING=277 +PASSWORD=278 +PLANS=279 +PRECEDING=280 +PREPARE=281 +PREPARED=282 +PRESERVE=283 +PRIOR=284 +PRIVILEGES=285 +PROCEDURAL=286 +PROCEDURE=287 +PROGRAM=288 +QUOTE=289 +RANGE=290 +READ=291 +REASSIGN=292 +RECHECK=293 +RECURSIVE=294 +REF=295 +REFRESH=296 +REINDEX=297 +RELATIVE_P=298 +RELEASE=299 +RENAME=300 +REPEATABLE=301 +REPLACE=302 +REPLICA=303 +RESET=304 +RESTART=305 +RESTRICT=306 +RETURNS=307 +REVOKE=308 +ROLE=309 +ROLLBACK=310 +ROWS=311 +RULE=312 +SAVEPOINT=313 +SCHEMA=314 +SCROLL=315 +SEARCH=316 +SECOND_P=317 +SECURITY=318 +SEQUENCE=319 +SEQUENCES=320 +SERIALIZABLE=321 +SERVER=322 +SESSION=323 +SET=324 +SHARE=325 +SHOW=326 +SIMPLE=327 +SNAPSHOT=328 +STABLE=329 +STANDALONE_P=330 +START=331 +STATEMENT=332 +STATISTICS=333 +STDIN=334 +STDOUT=335 +STORAGE=336 +STRICT_P=337 +STRIP_P=338 +SYSID=339 +SYSTEM_P=340 +TABLES=341 +TABLESPACE=342 +TEMP=343 +TEMPLATE=344 +TEMPORARY=345 +TEXT_P=346 +TRANSACTION=347 +TRIGGER=348 +TRUNCATE=349 +TRUSTED=350 +TYPE_P=351 +TYPES_P=352 +UNBOUNDED=353 +UNCOMMITTED=354 +UNENCRYPTED=355 +UNKNOWN=356 +UNLISTEN=357 +UNLOGGED=358 +UNTIL=359 +UPDATE=360 +VACUUM=361 +VALID=362 +VALIDATE=363 +VALIDATOR=364 +VARYING=365 +VERSION_P=366 +VIEW=367 +VOLATILE=368 +WHITESPACE_P=369 +WITHOUT=370 +WORK=371 +WRAPPER=372 +WRITE=373 +XML_P=374 +YEAR_P=375 +YES_P=376 +ZONE=377 +BETWEEN=378 +BIGINT=379 +BIT=380 +BOOLEAN_P=381 +CHAR_P=382 +CHARACTER=383 +COALESCE=384 +DEC=385 +DECIMAL_P=386 +EXISTS=387 +EXTRACT=388 +FLOAT_P=389 +GREATEST=390 +INOUT=391 +INT_P=392 +INTEGER=393 +INTERVAL=394 +LEAST=395 +NATIONAL=396 +NCHAR=397 +NONE=398 +NULLIF=399 +NUMERIC=400 +OVERLAY=401 +POSITION=402 +PRECISION=403 +REAL=404 +ROW=405 +SETOF=406 +SMALLINT=407 +SUBSTRING=408 +TIME=409 +TIMESTAMP=410 +TREAT=411 +TRIM=412 +VALUES=413 +VARCHAR=414 +XMLATTRIBUTES=415 +XMLCONCAT=416 +XMLELEMENT=417 +XMLEXISTS=418 +XMLFOREST=419 +XMLPARSE=420 +XMLPI=421 +XMLROOT=422 +XMLSERIALIZE=423 +CALL=424 +CURRENT_P=425 +ATTACH=426 +DETACH=427 +EXPRESSION=428 +GENERATED=429 +LOGGED=430 +STORED=431 +INCLUDE=432 +ROUTINE=433 +TRANSFORM=434 +IMPORT_P=435 +POLICY=436 +METHOD=437 +REFERENCING=438 +NEW=439 +OLD=440 +VALUE_P=441 +SUBSCRIPTION=442 +PUBLICATION=443 +OUT_P=444 +END_P=445 +ROUTINES=446 +SCHEMAS=447 +PROCEDURES=448 +INPUT_P=449 +SUPPORT=450 +PARALLEL=451 +SQL_P=452 +DEPENDS=453 +OVERRIDING=454 +CONFLICT=455 +SKIP_P=456 +LOCKED=457 +TIES=458 +ROLLUP=459 +CUBE=460 +GROUPING=461 +SETS=462 +TABLESAMPLE=463 +ORDINALITY=464 +XMLTABLE=465 +COLUMNS=466 +XMLNAMESPACES=467 +ROWTYPE=468 +NORMALIZED=469 +WITHIN=470 +FILTER=471 +GROUPS=472 +OTHERS=473 +NFC=474 +NFD=475 +NFKC=476 +NFKD=477 +UESCAPE=478 +VIEWS=479 +NORMALIZE=480 +DUMP=481 +PRINT_STRICT_PARAMS=482 +VARIABLE_CONFLICT=483 +ERROR=484 +USE_VARIABLE=485 +USE_COLUMN=486 +ALIAS=487 +CONSTANT=488 +PERFORM=489 +GET=490 +DIAGNOSTICS=491 +STACKED=492 +ELSIF=493 +WHILE=494 +REVERSE=495 +FOREACH=496 +SLICE=497 +EXIT=498 +RETURN=499 +QUERY=500 +RAISE=501 +SQLSTATE=502 +DEBUG=503 +LOG=504 +INFO=505 +NOTICE=506 +WARNING=507 +EXCEPTION=508 +ASSERT=509 +LOOP=510 +OPEN=511 +Identifier=512 +QuotedIdentifier=513 +UnterminatedQuotedIdentifier=514 +InvalidQuotedIdentifier=515 +InvalidUnterminatedQuotedIdentifier=516 +UnicodeQuotedIdentifier=517 +UnterminatedUnicodeQuotedIdentifier=518 +InvalidUnicodeQuotedIdentifier=519 +InvalidUnterminatedUnicodeQuotedIdentifier=520 +StringConstant=521 +UnterminatedStringConstant=522 +UnicodeEscapeStringConstant=523 +UnterminatedUnicodeEscapeStringConstant=524 +BeginDollarStringConstant=525 +BinaryStringConstant=526 +UnterminatedBinaryStringConstant=527 +InvalidBinaryStringConstant=528 +InvalidUnterminatedBinaryStringConstant=529 +HexadecimalStringConstant=530 +UnterminatedHexadecimalStringConstant=531 +InvalidHexadecimalStringConstant=532 +InvalidUnterminatedHexadecimalStringConstant=533 +Integral=534 +NumericFail=535 +Numeric=536 +PLSQLVARIABLENAME=537 +PLSQLIDENTIFIER=538 +Whitespace=539 +Newline=540 +LineComment=541 +BlockComment=542 +UnterminatedBlockComment=543 +MetaCommand=544 +EndMetaCommand=545 +ErrorCharacter=546 +EscapeStringConstant=547 +UnterminatedEscapeStringConstant=548 +InvalidEscapeStringConstant=549 +InvalidUnterminatedEscapeStringConstant=550 +AfterEscapeStringConstantMode_NotContinued=551 +AfterEscapeStringConstantWithNewlineMode_NotContinued=552 +DollarText=553 +EndDollarStringConstant=554 +AfterEscapeStringConstantWithNewlineMode_Continued=555 +'$'=1 +'('=2 +')'=3 +'['=4 +']'=5 +','=6 +';'=7 +':'=8 +'*'=9 +'='=10 +'.'=11 +'+'=12 +'-'=13 +'/'=14 +'^'=15 +'<'=16 +'>'=17 +'<<'=18 +'>>'=19 +':='=20 +'<='=21 +'=>'=22 +'>='=23 +'..'=24 +'<>'=25 +'::'=26 +'%'=27 +'ALL'=30 +'ANALYSE'=31 +'ANALYZE'=32 +'AND'=33 +'ANY'=34 +'ARRAY'=35 +'AS'=36 +'ASC'=37 +'ASYMMETRIC'=38 +'BOTH'=39 +'CASE'=40 +'CAST'=41 +'CHECK'=42 +'COLLATE'=43 +'COLUMN'=44 +'CONSTRAINT'=45 +'CREATE'=46 +'CURRENT_CATALOG'=47 +'CURRENT_DATE'=48 +'CURRENT_ROLE'=49 +'CURRENT_TIME'=50 +'CURRENT_TIMESTAMP'=51 +'CURRENT_USER'=52 +'DEFAULT'=53 +'DEFERRABLE'=54 +'DESC'=55 +'DISTINCT'=56 +'DO'=57 +'ELSE'=58 +'EXCEPT'=59 +'FALSE'=60 +'FETCH'=61 +'FOR'=62 +'FOREIGN'=63 +'FROM'=64 +'GRANT'=65 +'GROUP'=66 +'HAVING'=67 +'IN'=68 +'INITIALLY'=69 +'INTERSECT'=70 +'INTO'=71 +'LATERAL'=72 +'LEADING'=73 +'LIMIT'=74 +'LOCALTIME'=75 +'LOCALTIMESTAMP'=76 +'NOT'=77 +'NULL'=78 +'OFFSET'=79 +'ON'=80 +'ONLY'=81 +'OR'=82 +'ORDER'=83 +'PLACING'=84 +'PRIMARY'=85 +'REFERENCES'=86 +'RETURNING'=87 +'SELECT'=88 +'SESSION_USER'=89 +'SOME'=90 +'SYMMETRIC'=91 +'TABLE'=92 +'THEN'=93 +'TO'=94 +'TRAILING'=95 +'TRUE'=96 +'UNION'=97 +'UNIQUE'=98 +'USER'=99 +'USING'=100 +'VARIADIC'=101 +'WHEN'=102 +'WHERE'=103 +'WINDOW'=104 +'WITH'=105 +'AUTHORIZATION'=106 +'BINARY'=107 +'COLLATION'=108 +'CONCURRENTLY'=109 +'CROSS'=110 +'CURRENT_SCHEMA'=111 +'FREEZE'=112 +'FULL'=113 +'ILIKE'=114 +'INNER'=115 +'IS'=116 +'ISNULL'=117 +'JOIN'=118 +'LEFT'=119 +'LIKE'=120 +'NATURAL'=121 +'NOTNULL'=122 +'OUTER'=123 +'OVER'=124 +'OVERLAPS'=125 +'RIGHT'=126 +'SIMILAR'=127 +'VERBOSE'=128 +'ABORT'=129 +'ABSOLUTE'=130 +'ACCESS'=131 +'ACTION'=132 +'ADD'=133 +'ADMIN'=134 +'AFTER'=135 +'AGGREGATE'=136 +'ALSO'=137 +'ALTER'=138 +'ALWAYS'=139 +'ASSERTION'=140 +'ASSIGNMENT'=141 +'AT'=142 +'ATTRIBUTE'=143 +'BACKWARD'=144 +'BEFORE'=145 +'BEGIN'=146 +'BY'=147 +'CACHE'=148 +'CALLED'=149 +'CASCADE'=150 +'CASCADED'=151 +'CATALOG'=152 +'CHAIN'=153 +'CHARACTERISTICS'=154 +'CHECKPOINT'=155 +'CLASS'=156 +'CLOSE'=157 +'CLUSTER'=158 +'COMMENT'=159 +'COMMENTS'=160 +'COMMIT'=161 +'COMMITTED'=162 +'CONFIGURATION'=163 +'CONNECTION'=164 +'CONSTRAINTS'=165 +'CONTENT'=166 +'CONTINUE'=167 +'CONVERSION'=168 +'COPY'=169 +'COST'=170 +'CSV'=171 +'CURSOR'=172 +'CYCLE'=173 +'DATA'=174 +'DATABASE'=175 +'DAY'=176 +'DEALLOCATE'=177 +'DECLARE'=178 +'DEFAULTS'=179 +'DEFERRED'=180 +'DEFINER'=181 +'DELETE'=182 +'DELIMITER'=183 +'DELIMITERS'=184 +'DICTIONARY'=185 +'DISABLE'=186 +'DISCARD'=187 +'DOCUMENT'=188 +'DOMAIN'=189 +'DOUBLE'=190 +'DROP'=191 +'EACH'=192 +'ENABLE'=193 +'ENCODING'=194 +'ENCRYPTED'=195 +'ENUM'=196 +'ESCAPE'=197 +'EVENT'=198 +'EXCLUDE'=199 +'EXCLUDING'=200 +'EXCLUSIVE'=201 +'EXECUTE'=202 +'EXPLAIN'=203 +'EXTENSION'=204 +'EXTERNAL'=205 +'FAMILY'=206 +'FIRST'=207 +'FOLLOWING'=208 +'FORCE'=209 +'FORWARD'=210 +'FUNCTION'=211 +'FUNCTIONS'=212 +'GLOBAL'=213 +'GRANTED'=214 +'HANDLER'=215 +'HEADER'=216 +'HOLD'=217 +'HOUR'=218 +'IDENTITY'=219 +'IF'=220 +'IMMEDIATE'=221 +'IMMUTABLE'=222 +'IMPLICIT'=223 +'INCLUDING'=224 +'INCREMENT'=225 +'INDEX'=226 +'INDEXES'=227 +'INHERIT'=228 +'INHERITS'=229 +'INLINE'=230 +'INSENSITIVE'=231 +'INSERT'=232 +'INSTEAD'=233 +'INVOKER'=234 +'ISOLATION'=235 +'KEY'=236 +'LABEL'=237 +'LANGUAGE'=238 +'LARGE'=239 +'LAST'=240 +'LEAKPROOF'=241 +'LEVEL'=242 +'LISTEN'=243 +'LOAD'=244 +'LOCAL'=245 +'LOCATION'=246 +'LOCK'=247 +'MAPPING'=248 +'MATCH'=249 +'MATERIALIZED'=250 +'MAXVALUE'=251 +'MINUTE'=252 +'MINVALUE'=253 +'MODE'=254 +'MONTH'=255 +'MOVE'=256 +'NAME'=257 +'NAMES'=258 +'NEXT'=259 +'NO'=260 +'NOTHING'=261 +'NOTIFY'=262 +'NOWAIT'=263 +'NULLS'=264 +'OBJECT'=265 +'OF'=266 +'OFF'=267 +'OIDS'=268 +'OPERATOR'=269 +'OPTION'=270 +'OPTIONS'=271 +'OWNED'=272 +'OWNER'=273 +'PARSER'=274 +'PARTIAL'=275 +'PARTITION'=276 +'PASSING'=277 +'PASSWORD'=278 +'PLANS'=279 +'PRECEDING'=280 +'PREPARE'=281 +'PREPARED'=282 +'PRESERVE'=283 +'PRIOR'=284 +'PRIVILEGES'=285 +'PROCEDURAL'=286 +'PROCEDURE'=287 +'PROGRAM'=288 +'QUOTE'=289 +'RANGE'=290 +'READ'=291 +'REASSIGN'=292 +'RECHECK'=293 +'RECURSIVE'=294 +'REF'=295 +'REFRESH'=296 +'REINDEX'=297 +'RELATIVE'=298 +'RELEASE'=299 +'RENAME'=300 +'REPEATABLE'=301 +'REPLACE'=302 +'REPLICA'=303 +'RESET'=304 +'RESTART'=305 +'RESTRICT'=306 +'RETURNS'=307 +'REVOKE'=308 +'ROLE'=309 +'ROLLBACK'=310 +'ROWS'=311 +'RULE'=312 +'SAVEPOINT'=313 +'SCHEMA'=314 +'SCROLL'=315 +'SEARCH'=316 +'SECOND'=317 +'SECURITY'=318 +'SEQUENCE'=319 +'SEQUENCES'=320 +'SERIALIZABLE'=321 +'SERVER'=322 +'SESSION'=323 +'SET'=324 +'SHARE'=325 +'SHOW'=326 +'SIMPLE'=327 +'SNAPSHOT'=328 +'STABLE'=329 +'STANDALONE'=330 +'START'=331 +'STATEMENT'=332 +'STATISTICS'=333 +'STDIN'=334 +'STDOUT'=335 +'STORAGE'=336 +'STRICT'=337 +'STRIP'=338 +'SYSID'=339 +'SYSTEM'=340 +'TABLES'=341 +'TABLESPACE'=342 +'TEMP'=343 +'TEMPLATE'=344 +'TEMPORARY'=345 +'TEXT'=346 +'TRANSACTION'=347 +'TRIGGER'=348 +'TRUNCATE'=349 +'TRUSTED'=350 +'TYPE'=351 +'TYPES'=352 +'UNBOUNDED'=353 +'UNCOMMITTED'=354 +'UNENCRYPTED'=355 +'UNKNOWN'=356 +'UNLISTEN'=357 +'UNLOGGED'=358 +'UNTIL'=359 +'UPDATE'=360 +'VACUUM'=361 +'VALID'=362 +'VALIDATE'=363 +'VALIDATOR'=364 +'VARYING'=365 +'VERSION'=366 +'VIEW'=367 +'VOLATILE'=368 +'WHITESPACE'=369 +'WITHOUT'=370 +'WORK'=371 +'WRAPPER'=372 +'WRITE'=373 +'XML'=374 +'YEAR'=375 +'YES'=376 +'ZONE'=377 +'BETWEEN'=378 +'BIGINT'=379 +'BIT'=380 +'BOOLEAN'=381 +'CHAR'=382 +'CHARACTER'=383 +'COALESCE'=384 +'DEC'=385 +'DECIMAL'=386 +'EXISTS'=387 +'EXTRACT'=388 +'FLOAT'=389 +'GREATEST'=390 +'INOUT'=391 +'INT'=392 +'INTEGER'=393 +'INTERVAL'=394 +'LEAST'=395 +'NATIONAL'=396 +'NCHAR'=397 +'NONE'=398 +'NULLIF'=399 +'NUMERIC'=400 +'OVERLAY'=401 +'POSITION'=402 +'PRECISION'=403 +'REAL'=404 +'ROW'=405 +'SETOF'=406 +'SMALLINT'=407 +'SUBSTRING'=408 +'TIME'=409 +'TIMESTAMP'=410 +'TREAT'=411 +'TRIM'=412 +'VALUES'=413 +'VARCHAR'=414 +'XMLATTRIBUTES'=415 +'XMLCONCAT'=416 +'XMLELEMENT'=417 +'XMLEXISTS'=418 +'XMLFOREST'=419 +'XMLPARSE'=420 +'XMLPI'=421 +'XMLROOT'=422 +'XMLSERIALIZE'=423 +'CALL'=424 +'CURRENT'=425 +'ATTACH'=426 +'DETACH'=427 +'EXPRESSION'=428 +'GENERATED'=429 +'LOGGED'=430 +'STORED'=431 +'INCLUDE'=432 +'ROUTINE'=433 +'TRANSFORM'=434 +'IMPORT'=435 +'POLICY'=436 +'METHOD'=437 +'REFERENCING'=438 +'NEW'=439 +'OLD'=440 +'VALUE'=441 +'SUBSCRIPTION'=442 +'PUBLICATION'=443 +'OUT'=444 +'END'=445 +'ROUTINES'=446 +'SCHEMAS'=447 +'PROCEDURES'=448 +'INPUT'=449 +'SUPPORT'=450 +'PARALLEL'=451 +'SQL'=452 +'DEPENDS'=453 +'OVERRIDING'=454 +'CONFLICT'=455 +'SKIP'=456 +'LOCKED'=457 +'TIES'=458 +'ROLLUP'=459 +'CUBE'=460 +'GROUPING'=461 +'SETS'=462 +'TABLESAMPLE'=463 +'ORDINALITY'=464 +'XMLTABLE'=465 +'COLUMNS'=466 +'XMLNAMESPACES'=467 +'ROWTYPE'=468 +'NORMALIZED'=469 +'WITHIN'=470 +'FILTER'=471 +'GROUPS'=472 +'OTHERS'=473 +'NFC'=474 +'NFD'=475 +'NFKC'=476 +'NFKD'=477 +'UESCAPE'=478 +'VIEWS'=479 +'NORMALIZE'=480 +'DUMP'=481 +'PRINT_STRICT_PARAMS'=482 +'VARIABLE_CONFLICT'=483 +'ERROR'=484 +'USE_VARIABLE'=485 +'USE_COLUMN'=486 +'ALIAS'=487 +'CONSTANT'=488 +'PERFORM'=489 +'GET'=490 +'DIAGNOSTICS'=491 +'STACKED'=492 +'ELSIF'=493 +'WHILE'=494 +'REVERSE'=495 +'FOREACH'=496 +'SLICE'=497 +'EXIT'=498 +'RETURN'=499 +'QUERY'=500 +'RAISE'=501 +'SQLSTATE'=502 +'DEBUG'=503 +'LOG'=504 +'INFO'=505 +'NOTICE'=506 +'WARNING'=507 +'EXCEPTION'=508 +'ASSERT'=509 +'LOOP'=510 +'OPEN'=511 +'\\\\'=545 +'\''=555 diff --git a/src/lib/pgsql/PostgreSQLParser.interp b/src/lib/pgsql/PostgreSQLParser.interp new file mode 100644 index 0000000..927a331 --- /dev/null +++ b/src/lib/pgsql/PostgreSQLParser.interp @@ -0,0 +1,1925 @@ +token literal names: +null +'$' +'(' +')' +'[' +']' +',' +';' +':' +'*' +'=' +'.' +'+' +'-' +'/' +'^' +'<' +'>' +'<<' +'>>' +':=' +'<=' +'=>' +'>=' +'..' +'<>' +'::' +'%' +null +null +'ALL' +'ANALYSE' +'ANALYZE' +'AND' +'ANY' +'ARRAY' +'AS' +'ASC' +'ASYMMETRIC' +'BOTH' +'CASE' +'CAST' +'CHECK' +'COLLATE' +'COLUMN' +'CONSTRAINT' +'CREATE' +'CURRENT_CATALOG' +'CURRENT_DATE' +'CURRENT_ROLE' +'CURRENT_TIME' +'CURRENT_TIMESTAMP' +'CURRENT_USER' +'DEFAULT' +'DEFERRABLE' +'DESC' +'DISTINCT' +'DO' +'ELSE' +'EXCEPT' +'FALSE' +'FETCH' +'FOR' +'FOREIGN' +'FROM' +'GRANT' +'GROUP' +'HAVING' +'IN' +'INITIALLY' +'INTERSECT' +'INTO' +'LATERAL' +'LEADING' +'LIMIT' +'LOCALTIME' +'LOCALTIMESTAMP' +'NOT' +'NULL' +'OFFSET' +'ON' +'ONLY' +'OR' +'ORDER' +'PLACING' +'PRIMARY' +'REFERENCES' +'RETURNING' +'SELECT' +'SESSION_USER' +'SOME' +'SYMMETRIC' +'TABLE' +'THEN' +'TO' +'TRAILING' +'TRUE' +'UNION' +'UNIQUE' +'USER' +'USING' +'VARIADIC' +'WHEN' +'WHERE' +'WINDOW' +'WITH' +'AUTHORIZATION' +'BINARY' +'COLLATION' +'CONCURRENTLY' +'CROSS' +'CURRENT_SCHEMA' +'FREEZE' +'FULL' +'ILIKE' +'INNER' +'IS' +'ISNULL' +'JOIN' +'LEFT' +'LIKE' +'NATURAL' +'NOTNULL' +'OUTER' +'OVER' +'OVERLAPS' +'RIGHT' +'SIMILAR' +'VERBOSE' +'ABORT' +'ABSOLUTE' +'ACCESS' +'ACTION' +'ADD' +'ADMIN' +'AFTER' +'AGGREGATE' +'ALSO' +'ALTER' +'ALWAYS' +'ASSERTION' +'ASSIGNMENT' +'AT' +'ATTRIBUTE' +'BACKWARD' +'BEFORE' +'BEGIN' +'BY' +'CACHE' +'CALLED' +'CASCADE' +'CASCADED' +'CATALOG' +'CHAIN' +'CHARACTERISTICS' +'CHECKPOINT' +'CLASS' +'CLOSE' +'CLUSTER' +'COMMENT' +'COMMENTS' +'COMMIT' +'COMMITTED' +'CONFIGURATION' +'CONNECTION' +'CONSTRAINTS' +'CONTENT' +'CONTINUE' +'CONVERSION' +'COPY' +'COST' +'CSV' +'CURSOR' +'CYCLE' +'DATA' +'DATABASE' +'DAY' +'DEALLOCATE' +'DECLARE' +'DEFAULTS' +'DEFERRED' +'DEFINER' +'DELETE' +'DELIMITER' +'DELIMITERS' +'DICTIONARY' +'DISABLE' +'DISCARD' +'DOCUMENT' +'DOMAIN' +'DOUBLE' +'DROP' +'EACH' +'ENABLE' +'ENCODING' +'ENCRYPTED' +'ENUM' +'ESCAPE' +'EVENT' +'EXCLUDE' +'EXCLUDING' +'EXCLUSIVE' +'EXECUTE' +'EXPLAIN' +'EXTENSION' +'EXTERNAL' +'FAMILY' +'FIRST' +'FOLLOWING' +'FORCE' +'FORWARD' +'FUNCTION' +'FUNCTIONS' +'GLOBAL' +'GRANTED' +'HANDLER' +'HEADER' +'HOLD' +'HOUR' +'IDENTITY' +'IF' +'IMMEDIATE' +'IMMUTABLE' +'IMPLICIT' +'INCLUDING' +'INCREMENT' +'INDEX' +'INDEXES' +'INHERIT' +'INHERITS' +'INLINE' +'INSENSITIVE' +'INSERT' +'INSTEAD' +'INVOKER' +'ISOLATION' +'KEY' +'LABEL' +'LANGUAGE' +'LARGE' +'LAST' +'LEAKPROOF' +'LEVEL' +'LISTEN' +'LOAD' +'LOCAL' +'LOCATION' +'LOCK' +'MAPPING' +'MATCH' +'MATERIALIZED' +'MAXVALUE' +'MINUTE' +'MINVALUE' +'MODE' +'MONTH' +'MOVE' +'NAME' +'NAMES' +'NEXT' +'NO' +'NOTHING' +'NOTIFY' +'NOWAIT' +'NULLS' +'OBJECT' +'OF' +'OFF' +'OIDS' +'OPERATOR' +'OPTION' +'OPTIONS' +'OWNED' +'OWNER' +'PARSER' +'PARTIAL' +'PARTITION' +'PASSING' +'PASSWORD' +'PLANS' +'PRECEDING' +'PREPARE' +'PREPARED' +'PRESERVE' +'PRIOR' +'PRIVILEGES' +'PROCEDURAL' +'PROCEDURE' +'PROGRAM' +'QUOTE' +'RANGE' +'READ' +'REASSIGN' +'RECHECK' +'RECURSIVE' +'REF' +'REFRESH' +'REINDEX' +'RELATIVE' +'RELEASE' +'RENAME' +'REPEATABLE' +'REPLACE' +'REPLICA' +'RESET' +'RESTART' +'RESTRICT' +'RETURNS' +'REVOKE' +'ROLE' +'ROLLBACK' +'ROWS' +'RULE' +'SAVEPOINT' +'SCHEMA' +'SCROLL' +'SEARCH' +'SECOND' +'SECURITY' +'SEQUENCE' +'SEQUENCES' +'SERIALIZABLE' +'SERVER' +'SESSION' +'SET' +'SHARE' +'SHOW' +'SIMPLE' +'SNAPSHOT' +'STABLE' +'STANDALONE' +'START' +'STATEMENT' +'STATISTICS' +'STDIN' +'STDOUT' +'STORAGE' +'STRICT' +'STRIP' +'SYSID' +'SYSTEM' +'TABLES' +'TABLESPACE' +'TEMP' +'TEMPLATE' +'TEMPORARY' +'TEXT' +'TRANSACTION' +'TRIGGER' +'TRUNCATE' +'TRUSTED' +'TYPE' +'TYPES' +'UNBOUNDED' +'UNCOMMITTED' +'UNENCRYPTED' +'UNKNOWN' +'UNLISTEN' +'UNLOGGED' +'UNTIL' +'UPDATE' +'VACUUM' +'VALID' +'VALIDATE' +'VALIDATOR' +'VARYING' +'VERSION' +'VIEW' +'VOLATILE' +'WHITESPACE' +'WITHOUT' +'WORK' +'WRAPPER' +'WRITE' +'XML' +'YEAR' +'YES' +'ZONE' +'BETWEEN' +'BIGINT' +'BIT' +'BOOLEAN' +'CHAR' +'CHARACTER' +'COALESCE' +'DEC' +'DECIMAL' +'EXISTS' +'EXTRACT' +'FLOAT' +'GREATEST' +'INOUT' +'INT' +'INTEGER' +'INTERVAL' +'LEAST' +'NATIONAL' +'NCHAR' +'NONE' +'NULLIF' +'NUMERIC' +'OVERLAY' +'POSITION' +'PRECISION' +'REAL' +'ROW' +'SETOF' +'SMALLINT' +'SUBSTRING' +'TIME' +'TIMESTAMP' +'TREAT' +'TRIM' +'VALUES' +'VARCHAR' +'XMLATTRIBUTES' +'XMLCONCAT' +'XMLELEMENT' +'XMLEXISTS' +'XMLFOREST' +'XMLPARSE' +'XMLPI' +'XMLROOT' +'XMLSERIALIZE' +'CALL' +'CURRENT' +'ATTACH' +'DETACH' +'EXPRESSION' +'GENERATED' +'LOGGED' +'STORED' +'INCLUDE' +'ROUTINE' +'TRANSFORM' +'IMPORT' +'POLICY' +'METHOD' +'REFERENCING' +'NEW' +'OLD' +'VALUE' +'SUBSCRIPTION' +'PUBLICATION' +'OUT' +'END' +'ROUTINES' +'SCHEMAS' +'PROCEDURES' +'INPUT' +'SUPPORT' +'PARALLEL' +'SQL' +'DEPENDS' +'OVERRIDING' +'CONFLICT' +'SKIP' +'LOCKED' +'TIES' +'ROLLUP' +'CUBE' +'GROUPING' +'SETS' +'TABLESAMPLE' +'ORDINALITY' +'XMLTABLE' +'COLUMNS' +'XMLNAMESPACES' +'ROWTYPE' +'NORMALIZED' +'WITHIN' +'FILTER' +'GROUPS' +'OTHERS' +'NFC' +'NFD' +'NFKC' +'NFKD' +'UESCAPE' +'VIEWS' +'NORMALIZE' +'DUMP' +'PRINT_STRICT_PARAMS' +'VARIABLE_CONFLICT' +'ERROR' +'USE_VARIABLE' +'USE_COLUMN' +'ALIAS' +'CONSTANT' +'PERFORM' +'GET' +'DIAGNOSTICS' +'STACKED' +'ELSIF' +'WHILE' +'REVERSE' +'FOREACH' +'SLICE' +'EXIT' +'RETURN' +'QUERY' +'RAISE' +'SQLSTATE' +'DEBUG' +'LOG' +'INFO' +'NOTICE' +'WARNING' +'EXCEPTION' +'ASSERT' +'LOOP' +'OPEN' +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +null +'\\\\' +null +null +null +null +null +null +null +null +null +'\'' + +token symbolic names: +null +Dollar +OPEN_PAREN +CLOSE_PAREN +OPEN_BRACKET +CLOSE_BRACKET +COMMA +SEMI +COLON +STAR +EQUAL +DOT +PLUS +MINUS +SLASH +CARET +LT +GT +LESS_LESS +GREATER_GREATER +COLON_EQUALS +LESS_EQUALS +EQUALS_GREATER +GREATER_EQUALS +DOT_DOT +NOT_EQUALS +TYPECAST +PERCENT +PARAM +Operator +ALL +ANALYSE +ANALYZE +AND +ANY +ARRAY +AS +ASC +ASYMMETRIC +BOTH +CASE +CAST +CHECK +COLLATE +COLUMN +CONSTRAINT +CREATE +CURRENT_CATALOG +CURRENT_DATE +CURRENT_ROLE +CURRENT_TIME +CURRENT_TIMESTAMP +CURRENT_USER +DEFAULT +DEFERRABLE +DESC +DISTINCT +DO +ELSE +EXCEPT +FALSE_P +FETCH +FOR +FOREIGN +FROM +GRANT +GROUP_P +HAVING +IN_P +INITIALLY +INTERSECT +INTO +LATERAL_P +LEADING +LIMIT +LOCALTIME +LOCALTIMESTAMP +NOT +NULL_P +OFFSET +ON +ONLY +OR +ORDER +PLACING +PRIMARY +REFERENCES +RETURNING +SELECT +SESSION_USER +SOME +SYMMETRIC +TABLE +THEN +TO +TRAILING +TRUE_P +UNION +UNIQUE +USER +USING +VARIADIC +WHEN +WHERE +WINDOW +WITH +AUTHORIZATION +BINARY +COLLATION +CONCURRENTLY +CROSS +CURRENT_SCHEMA +FREEZE +FULL +ILIKE +INNER_P +IS +ISNULL +JOIN +LEFT +LIKE +NATURAL +NOTNULL +OUTER_P +OVER +OVERLAPS +RIGHT +SIMILAR +VERBOSE +ABORT_P +ABSOLUTE_P +ACCESS +ACTION +ADD_P +ADMIN +AFTER +AGGREGATE +ALSO +ALTER +ALWAYS +ASSERTION +ASSIGNMENT +AT +ATTRIBUTE +BACKWARD +BEFORE +BEGIN_P +BY +CACHE +CALLED +CASCADE +CASCADED +CATALOG +CHAIN +CHARACTERISTICS +CHECKPOINT +CLASS +CLOSE +CLUSTER +COMMENT +COMMENTS +COMMIT +COMMITTED +CONFIGURATION +CONNECTION +CONSTRAINTS +CONTENT_P +CONTINUE_P +CONVERSION_P +COPY +COST +CSV +CURSOR +CYCLE +DATA_P +DATABASE +DAY_P +DEALLOCATE +DECLARE +DEFAULTS +DEFERRED +DEFINER +DELETE_P +DELIMITER +DELIMITERS +DICTIONARY +DISABLE_P +DISCARD +DOCUMENT_P +DOMAIN_P +DOUBLE_P +DROP +EACH +ENABLE_P +ENCODING +ENCRYPTED +ENUM_P +ESCAPE +EVENT +EXCLUDE +EXCLUDING +EXCLUSIVE +EXECUTE +EXPLAIN +EXTENSION +EXTERNAL +FAMILY +FIRST_P +FOLLOWING +FORCE +FORWARD +FUNCTION +FUNCTIONS +GLOBAL +GRANTED +HANDLER +HEADER_P +HOLD +HOUR_P +IDENTITY_P +IF_P +IMMEDIATE +IMMUTABLE +IMPLICIT_P +INCLUDING +INCREMENT +INDEX +INDEXES +INHERIT +INHERITS +INLINE_P +INSENSITIVE +INSERT +INSTEAD +INVOKER +ISOLATION +KEY +LABEL +LANGUAGE +LARGE_P +LAST_P +LEAKPROOF +LEVEL +LISTEN +LOAD +LOCAL +LOCATION +LOCK_P +MAPPING +MATCH +MATERIALIZED +MAXVALUE +MINUTE_P +MINVALUE +MODE +MONTH_P +MOVE +NAME_P +NAMES +NEXT +NO +NOTHING +NOTIFY +NOWAIT +NULLS_P +OBJECT_P +OF +OFF +OIDS +OPERATOR +OPTION +OPTIONS +OWNED +OWNER +PARSER +PARTIAL +PARTITION +PASSING +PASSWORD +PLANS +PRECEDING +PREPARE +PREPARED +PRESERVE +PRIOR +PRIVILEGES +PROCEDURAL +PROCEDURE +PROGRAM +QUOTE +RANGE +READ +REASSIGN +RECHECK +RECURSIVE +REF +REFRESH +REINDEX +RELATIVE_P +RELEASE +RENAME +REPEATABLE +REPLACE +REPLICA +RESET +RESTART +RESTRICT +RETURNS +REVOKE +ROLE +ROLLBACK +ROWS +RULE +SAVEPOINT +SCHEMA +SCROLL +SEARCH +SECOND_P +SECURITY +SEQUENCE +SEQUENCES +SERIALIZABLE +SERVER +SESSION +SET +SHARE +SHOW +SIMPLE +SNAPSHOT +STABLE +STANDALONE_P +START +STATEMENT +STATISTICS +STDIN +STDOUT +STORAGE +STRICT_P +STRIP_P +SYSID +SYSTEM_P +TABLES +TABLESPACE +TEMP +TEMPLATE +TEMPORARY +TEXT_P +TRANSACTION +TRIGGER +TRUNCATE +TRUSTED +TYPE_P +TYPES_P +UNBOUNDED +UNCOMMITTED +UNENCRYPTED +UNKNOWN +UNLISTEN +UNLOGGED +UNTIL +UPDATE +VACUUM +VALID +VALIDATE +VALIDATOR +VARYING +VERSION_P +VIEW +VOLATILE +WHITESPACE_P +WITHOUT +WORK +WRAPPER +WRITE +XML_P +YEAR_P +YES_P +ZONE +BETWEEN +BIGINT +BIT +BOOLEAN_P +CHAR_P +CHARACTER +COALESCE +DEC +DECIMAL_P +EXISTS +EXTRACT +FLOAT_P +GREATEST +INOUT +INT_P +INTEGER +INTERVAL +LEAST +NATIONAL +NCHAR +NONE +NULLIF +NUMERIC +OVERLAY +POSITION +PRECISION +REAL +ROW +SETOF +SMALLINT +SUBSTRING +TIME +TIMESTAMP +TREAT +TRIM +VALUES +VARCHAR +XMLATTRIBUTES +XMLCONCAT +XMLELEMENT +XMLEXISTS +XMLFOREST +XMLPARSE +XMLPI +XMLROOT +XMLSERIALIZE +CALL +CURRENT_P +ATTACH +DETACH +EXPRESSION +GENERATED +LOGGED +STORED +INCLUDE +ROUTINE +TRANSFORM +IMPORT_P +POLICY +METHOD +REFERENCING +NEW +OLD +VALUE_P +SUBSCRIPTION +PUBLICATION +OUT_P +END_P +ROUTINES +SCHEMAS +PROCEDURES +INPUT_P +SUPPORT +PARALLEL +SQL_P +DEPENDS +OVERRIDING +CONFLICT +SKIP_P +LOCKED +TIES +ROLLUP +CUBE +GROUPING +SETS +TABLESAMPLE +ORDINALITY +XMLTABLE +COLUMNS +XMLNAMESPACES +ROWTYPE +NORMALIZED +WITHIN +FILTER +GROUPS +OTHERS +NFC +NFD +NFKC +NFKD +UESCAPE +VIEWS +NORMALIZE +DUMP +PRINT_STRICT_PARAMS +VARIABLE_CONFLICT +ERROR +USE_VARIABLE +USE_COLUMN +ALIAS +CONSTANT +PERFORM +GET +DIAGNOSTICS +STACKED +ELSIF +WHILE +REVERSE +FOREACH +SLICE +EXIT +RETURN +QUERY +RAISE +SQLSTATE +DEBUG +LOG +INFO +NOTICE +WARNING +EXCEPTION +ASSERT +LOOP +OPEN +Identifier +QuotedIdentifier +UnterminatedQuotedIdentifier +InvalidQuotedIdentifier +InvalidUnterminatedQuotedIdentifier +UnicodeQuotedIdentifier +UnterminatedUnicodeQuotedIdentifier +InvalidUnicodeQuotedIdentifier +InvalidUnterminatedUnicodeQuotedIdentifier +StringConstant +UnterminatedStringConstant +UnicodeEscapeStringConstant +UnterminatedUnicodeEscapeStringConstant +BeginDollarStringConstant +BinaryStringConstant +UnterminatedBinaryStringConstant +InvalidBinaryStringConstant +InvalidUnterminatedBinaryStringConstant +HexadecimalStringConstant +UnterminatedHexadecimalStringConstant +InvalidHexadecimalStringConstant +InvalidUnterminatedHexadecimalStringConstant +Integral +NumericFail +Numeric +PLSQLVARIABLENAME +PLSQLIDENTIFIER +Whitespace +Newline +LineComment +BlockComment +UnterminatedBlockComment +MetaCommand +EndMetaCommand +ErrorCharacter +EscapeStringConstant +UnterminatedEscapeStringConstant +InvalidEscapeStringConstant +InvalidUnterminatedEscapeStringConstant +AfterEscapeStringConstantMode_NotContinued +AfterEscapeStringConstantWithNewlineMode_NotContinued +DollarText +EndDollarStringConstant +AfterEscapeStringConstantWithNewlineMode_Continued + +rule names: +root +plsqlroot +stmtblock +stmtmulti +stmt +plsqlconsolecommand +callstmt +createrolestmt +opt_with +optrolelist +alteroptrolelist +alteroptroleelem +createoptroleelem +createuserstmt +alterrolestmt +opt_in_database +alterrolesetstmt +droprolestmt +creategroupstmt +altergroupstmt +add_drop +createschemastmt +optschemaname +optschemaeltlist +schema_stmt +variablesetstmt +set_rest +generic_set +set_rest_more +var_name +var_list +var_value +iso_level +opt_boolean_or_string +zone_value +opt_encoding +nonreservedword_or_sconst +variableresetstmt +reset_rest +generic_reset +setresetclause +functionsetresetclause +variableshowstmt +constraintssetstmt +constraints_set_list +constraints_set_mode +checkpointstmt +discardstmt +altertablestmt +alter_table_cmds +partition_cmd +index_partition_cmd +alter_table_cmd +alter_column_default +opt_drop_behavior +opt_collate_clause +alter_using +replica_identity +reloptions +opt_reloptions +reloption_list +reloption_elem +alter_identity_column_option_list +alter_identity_column_option +partitionboundspec +hash_partbound_elem +hash_partbound +altercompositetypestmt +alter_type_cmds +alter_type_cmd +closeportalstmt +copystmt +copy_from +opt_program +copy_file_name +copy_options +copy_opt_list +copy_opt_item +opt_binary +copy_delimiter +opt_using +copy_generic_opt_list +copy_generic_opt_elem +copy_generic_opt_arg +copy_generic_opt_arg_list +copy_generic_opt_arg_list_item +createstmt +opttemp +opttableelementlist +opttypedtableelementlist +tableelementlist +typedtableelementlist +tableelement +typedtableelement +columnDef +columnOptions +colquallist +colconstraint +colconstraintelem +generated_when +constraintattr +tablelikeclause +tablelikeoptionlist +tablelikeoption +tableconstraint +constraintelem +opt_no_inherit +opt_column_list +columnlist +columnElem +opt_c_include +key_match +exclusionconstraintlist +exclusionconstraintelem +exclusionwhereclause +key_actions +key_update +key_delete +key_action +optinherit +optpartitionspec +partitionspec +part_params +part_elem +table_access_method_clause +optwith +oncommitoption +opttablespace +optconstablespace +existingindex +createstatsstmt +alterstatsstmt +createasstmt +create_as_target +opt_with_data +creatematviewstmt +create_mv_target +optnolog +refreshmatviewstmt +createseqstmt +alterseqstmt +optseqoptlist +optparenthesizedseqoptlist +seqoptlist +seqoptelem +opt_by +numericonly +numericonly_list +createplangstmt +opt_trusted +handler_name +opt_inline_handler +validator_clause +opt_validator +opt_procedural +createtablespacestmt +opttablespaceowner +droptablespacestmt +createextensionstmt +create_extension_opt_list +create_extension_opt_item +alterextensionstmt +alter_extension_opt_list +alter_extension_opt_item +alterextensioncontentsstmt +createfdwstmt +fdw_option +fdw_options +opt_fdw_options +alterfdwstmt +create_generic_options +generic_option_list +alter_generic_options +alter_generic_option_list +alter_generic_option_elem +generic_option_elem +generic_option_name +generic_option_arg +createforeignserverstmt +opt_type +foreign_server_version +opt_foreign_server_version +alterforeignserverstmt +createforeigntablestmt +importforeignschemastmt +import_qualification_type +import_qualification +createusermappingstmt +auth_ident +dropusermappingstmt +alterusermappingstmt +createpolicystmt +alterpolicystmt +rowsecurityoptionalexpr +rowsecurityoptionalwithcheck +rowsecuritydefaulttorole +rowsecurityoptionaltorole +rowsecuritydefaultpermissive +rowsecuritydefaultforcmd +row_security_cmd +createamstmt +am_type +createtrigstmt +triggeractiontime +triggerevents +triggeroneevent +triggerreferencing +triggertransitions +triggertransition +transitionoldornew +transitionrowortable +transitionrelname +triggerforspec +triggerforopteach +triggerfortype +triggerwhen +function_or_procedure +triggerfuncargs +triggerfuncarg +optconstrfromtable +constraintattributespec +constraintattributeElem +createeventtrigstmt +event_trigger_when_list +event_trigger_when_item +event_trigger_value_list +altereventtrigstmt +enable_trigger +createassertionstmt +definestmt +definition +def_list +def_elem +def_arg +old_aggr_definition +old_aggr_list +old_aggr_elem +opt_enum_val_list +enum_val_list +alterenumstmt +opt_if_not_exists +createopclassstmt +opclass_item_list +opclass_item +opt_default +opt_opfamily +opclass_purpose +opt_recheck +createopfamilystmt +alteropfamilystmt +opclass_drop_list +opclass_drop +dropopclassstmt +dropopfamilystmt +dropownedstmt +reassignownedstmt +dropstmt +object_type_any_name +object_type_name +drop_type_name +object_type_name_on_any_name +any_name_list +any_name +attrs +type_name_list +truncatestmt +opt_restart_seqs +commentstmt +comment_text +seclabelstmt +opt_provider +security_label +fetchstmt +fetch_args +from_in +opt_from_in +grantstmt +revokestmt +privileges +privilege_list +privilege +privilege_target +grantee_list +grantee +opt_grant_grant_option +grantrolestmt +revokerolestmt +opt_grant_admin_option +opt_granted_by +alterdefaultprivilegesstmt +defacloptionlist +defacloption +defaclaction +defacl_privilege_target +indexstmt +opt_unique +opt_concurrently +opt_index_name +access_method_clause +index_params +index_elem_options +index_elem +opt_include +index_including_params +opt_collate +opt_class +opt_asc_desc +opt_nulls_order +createfunctionstmt +opt_or_replace +func_args +func_args_list +function_with_argtypes_list +function_with_argtypes +func_args_with_defaults +func_args_with_defaults_list +func_arg +arg_class +param_name +func_return +func_type +func_arg_with_default +aggr_arg +aggr_args +aggr_args_list +aggregate_with_argtypes +aggregate_with_argtypes_list +createfunc_opt_list +common_func_opt_item +createfunc_opt_item +func_as +transform_type_list +opt_definition +table_func_column +table_func_column_list +alterfunctionstmt +alterfunc_opt_list +opt_restrict +removefuncstmt +removeaggrstmt +removeoperstmt +oper_argtypes +any_operator +operator_with_argtypes_list +operator_with_argtypes +dostmt +dostmt_opt_list +dostmt_opt_item +createcaststmt +cast_context +dropcaststmt +opt_if_exists +createtransformstmt +transform_element_list +droptransformstmt +reindexstmt +reindex_target_type +reindex_target_multitable +reindex_option_list +reindex_option_elem +altertblspcstmt +renamestmt +opt_column +opt_set_data +alterobjectdependsstmt +opt_no +alterobjectschemastmt +alteroperatorstmt +operator_def_list +operator_def_elem +operator_def_arg +altertypestmt +alterownerstmt +createpublicationstmt +opt_publication_for_tables +publication_for_tables +alterpublicationstmt +createsubscriptionstmt +publication_name_list +publication_name_item +altersubscriptionstmt +dropsubscriptionstmt +rulestmt +ruleactionlist +ruleactionmulti +ruleactionstmt +ruleactionstmtOrEmpty +event +opt_instead +notifystmt +notify_payload +listenstmt +unlistenstmt +transactionstmt +opt_transaction +transaction_mode_item +transaction_mode_list +transaction_mode_list_or_empty +opt_transaction_chain +viewstmt +opt_check_option +loadstmt +createdbstmt +createdb_opt_list +createdb_opt_items +createdb_opt_item +createdb_opt_name +opt_equal +alterdatabasestmt +alterdatabasesetstmt +dropdbstmt +drop_option_list +drop_option +altercollationstmt +altersystemstmt +createdomainstmt +alterdomainstmt +opt_as +altertsdictionarystmt +altertsconfigurationstmt +any_with +createconversionstmt +clusterstmt +cluster_index_specification +vacuumstmt +analyzestmt +vac_analyze_option_list +analyze_keyword +vac_analyze_option_elem +vac_analyze_option_name +vac_analyze_option_arg +opt_analyze +opt_verbose +opt_full +opt_freeze +opt_name_list +vacuum_relation +vacuum_relation_list +opt_vacuum_relation_list +explainstmt +explainablestmt +explain_option_list +explain_option_elem +explain_option_name +explain_option_arg +preparestmt +prep_type_clause +preparablestmt +executestmt +execute_param_clause +deallocatestmt +insertstmt +insert_target +insert_rest +override_kind +insert_column_list +insert_column_item +opt_on_conflict +opt_conf_expr +returning_clause +deletestmt +using_clause +lockstmt +opt_lock +lock_type +opt_nowait +opt_nowait_or_skip +updatestmt +set_clause_list +set_clause +set_target +set_target_list +declarecursorstmt +cursor_name +cursor_options +opt_hold +selectstmt +select_with_parens +select_no_parens +select_clause +simple_select +set_operator +set_operator_with_all_or_distinct +with_clause +cte_list +common_table_expr +opt_materialized +opt_with_clause +into_clause +opt_strict +opttempTableName +opt_table +all_or_distinct +distinct_clause +opt_all_clause +opt_sort_clause +sort_clause +sortby_list +sortby +select_limit +opt_select_limit +limit_clause +offset_clause +select_limit_value +select_offset_value +select_fetch_first_value +i_or_f_const +row_or_rows +first_or_next +group_clause +group_by_list +group_by_item +empty_grouping_set +rollup_clause +cube_clause +grouping_sets_clause +having_clause +for_locking_clause +opt_for_locking_clause +for_locking_items +for_locking_item +for_locking_strength +locked_rels_list +values_clause +from_clause +from_list +table_ref +alias_clause +opt_alias_clause +func_alias_clause +join_type +join_qual +relation_expr +relation_expr_list +relation_expr_opt_alias +tablesample_clause +opt_repeatable_clause +func_table +rowsfrom_item +rowsfrom_list +opt_col_def_list +opt_ordinality +where_clause +where_or_current_clause +opttablefuncelementlist +tablefuncelementlist +tablefuncelement +xmltable +xmltable_column_list +xmltable_column_el +xmltable_column_option_list +xmltable_column_option_el +xml_namespace_list +xml_namespace_el +typename +opt_array_bounds +simpletypename +consttypename +generictype +opt_type_modifiers +numeric +opt_float +bit +constbit +bitwithlength +bitwithoutlength +character +constcharacter +character_c +opt_varying +constdatetime +constinterval +opt_timezone +opt_interval +interval_second +opt_escape +a_expr +a_expr_qual +a_expr_lessless +a_expr_or +a_expr_and +a_expr_in +a_expr_unary_not +a_expr_isnull +a_expr_is_not +a_expr_compare +a_expr_like +a_expr_qual_op +a_expr_unary_qualop +a_expr_add +a_expr_mul +a_expr_caret +a_expr_unary_sign +a_expr_at_time_zone +a_expr_collate +a_expr_typecast +b_expr +c_expr +plsqlvariablename +func_application +func_expr +func_expr_windowless +func_expr_common_subexpr +xml_root_version +opt_xml_root_standalone +xml_attributes +xml_attribute_list +xml_attribute_el +document_or_content +xml_whitespace_option +xmlexists_argument +xml_passing_mech +within_group_clause +filter_clause +window_clause +window_definition_list +window_definition +over_clause +window_specification +opt_existing_window_name +opt_partition_clause +opt_frame_clause +frame_extent +frame_bound +opt_window_exclusion_clause +row +explicit_row +implicit_row +sub_type +all_op +mathop +qual_op +qual_all_op +subquery_Op +expr_list +func_arg_list +func_arg_expr +type_list +array_expr +array_expr_list +extract_list +extract_arg +unicode_normal_form +overlay_list +position_list +substr_list +trim_list +in_expr +case_expr +when_clause_list +when_clause +case_default +case_arg +columnref +indirection_el +opt_slice_bound +indirection +opt_indirection +opt_target_list +target_list +target_el +qualified_name_list +qualified_name +name_list +name +attr_name +file_name +func_name +aexprconst +xconst +bconst +fconst +iconst +sconst +anysconst +opt_uescape +signediconst +roleid +rolespec +role_list +colid +type_function_name +nonreservedword +collabel +identifier +plsqlidentifier +unreserved_keyword +col_name_keyword +type_func_name_keyword +reserved_keyword +pl_function +comp_options +comp_option +sharp +option_value +opt_semi +pl_block +decl_sect +decl_start +decl_stmts +label_decl +decl_stmt +decl_statement +opt_scrollable +decl_cursor_query +decl_cursor_args +decl_cursor_arglist +decl_cursor_arg +decl_is_for +decl_aliasitem +decl_varname +decl_const +decl_datatype +decl_collate +decl_notnull +decl_defval +decl_defkey +assign_operator +proc_sect +proc_stmt +stmt_perform +stmt_call +opt_expr_list +stmt_assign +stmt_getdiag +getdiag_area_opt +getdiag_list +getdiag_list_item +getdiag_item +getdiag_target +assign_var +stmt_if +stmt_elsifs +stmt_else +stmt_case +opt_expr_until_when +case_when_list +case_when +opt_case_else +stmt_loop +stmt_while +stmt_for +for_control +opt_for_using_expression +opt_cursor_parameters +opt_reverse +opt_by_expression +for_variable +stmt_foreach_a +foreach_slice +stmt_exit +exit_type +stmt_return +opt_return_result +stmt_raise +opt_stmt_raise_level +opt_raise_list +opt_raise_using +opt_raise_using_elem +opt_raise_using_elem_list +stmt_assert +opt_stmt_assert_message +loop_body +stmt_execsql +stmt_dynexecute +opt_execute_using +opt_execute_using_list +opt_execute_into +stmt_open +opt_open_bound_list_item +opt_open_bound_list +opt_open_using +opt_scroll_option +opt_scroll_option_no +stmt_fetch +into_target +opt_cursor_from +opt_fetch_direction +stmt_move +stmt_close +stmt_null +stmt_commit +stmt_rollback +plsql_opt_transaction_chain +stmt_set +cursor_variable +exception_sect +proc_exceptions +proc_exception +proc_conditions +proc_condition +opt_block_label +opt_loop_label +opt_label +opt_exitcond +any_identifier +plsql_unreserved_keyword +sql_expression +expr_until_then +expr_until_semi +expr_until_rightbracket +expr_until_loop +make_execsql_stmt +opt_returning_clause_into + + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 557, 10563, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174, 9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178, 4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183, 9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187, 4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 4, 191, 9, 191, 4, 192, 9, 192, 4, 193, 9, 193, 4, 194, 9, 194, 4, 195, 9, 195, 4, 196, 9, 196, 4, 197, 9, 197, 4, 198, 9, 198, 4, 199, 9, 199, 4, 200, 9, 200, 4, 201, 9, 201, 4, 202, 9, 202, 4, 203, 9, 203, 4, 204, 9, 204, 4, 205, 9, 205, 4, 206, 9, 206, 4, 207, 9, 207, 4, 208, 9, 208, 4, 209, 9, 209, 4, 210, 9, 210, 4, 211, 9, 211, 4, 212, 9, 212, 4, 213, 9, 213, 4, 214, 9, 214, 4, 215, 9, 215, 4, 216, 9, 216, 4, 217, 9, 217, 4, 218, 9, 218, 4, 219, 9, 219, 4, 220, 9, 220, 4, 221, 9, 221, 4, 222, 9, 222, 4, 223, 9, 223, 4, 224, 9, 224, 4, 225, 9, 225, 4, 226, 9, 226, 4, 227, 9, 227, 4, 228, 9, 228, 4, 229, 9, 229, 4, 230, 9, 230, 4, 231, 9, 231, 4, 232, 9, 232, 4, 233, 9, 233, 4, 234, 9, 234, 4, 235, 9, 235, 4, 236, 9, 236, 4, 237, 9, 237, 4, 238, 9, 238, 4, 239, 9, 239, 4, 240, 9, 240, 4, 241, 9, 241, 4, 242, 9, 242, 4, 243, 9, 243, 4, 244, 9, 244, 4, 245, 9, 245, 4, 246, 9, 246, 4, 247, 9, 247, 4, 248, 9, 248, 4, 249, 9, 249, 4, 250, 9, 250, 4, 251, 9, 251, 4, 252, 9, 252, 4, 253, 9, 253, 4, 254, 9, 254, 4, 255, 9, 255, 4, 256, 9, 256, 4, 257, 9, 257, 4, 258, 9, 258, 4, 259, 9, 259, 4, 260, 9, 260, 4, 261, 9, 261, 4, 262, 9, 262, 4, 263, 9, 263, 4, 264, 9, 264, 4, 265, 9, 265, 4, 266, 9, 266, 4, 267, 9, 267, 4, 268, 9, 268, 4, 269, 9, 269, 4, 270, 9, 270, 4, 271, 9, 271, 4, 272, 9, 272, 4, 273, 9, 273, 4, 274, 9, 274, 4, 275, 9, 275, 4, 276, 9, 276, 4, 277, 9, 277, 4, 278, 9, 278, 4, 279, 9, 279, 4, 280, 9, 280, 4, 281, 9, 281, 4, 282, 9, 282, 4, 283, 9, 283, 4, 284, 9, 284, 4, 285, 9, 285, 4, 286, 9, 286, 4, 287, 9, 287, 4, 288, 9, 288, 4, 289, 9, 289, 4, 290, 9, 290, 4, 291, 9, 291, 4, 292, 9, 292, 4, 293, 9, 293, 4, 294, 9, 294, 4, 295, 9, 295, 4, 296, 9, 296, 4, 297, 9, 297, 4, 298, 9, 298, 4, 299, 9, 299, 4, 300, 9, 300, 4, 301, 9, 301, 4, 302, 9, 302, 4, 303, 9, 303, 4, 304, 9, 304, 4, 305, 9, 305, 4, 306, 9, 306, 4, 307, 9, 307, 4, 308, 9, 308, 4, 309, 9, 309, 4, 310, 9, 310, 4, 311, 9, 311, 4, 312, 9, 312, 4, 313, 9, 313, 4, 314, 9, 314, 4, 315, 9, 315, 4, 316, 9, 316, 4, 317, 9, 317, 4, 318, 9, 318, 4, 319, 9, 319, 4, 320, 9, 320, 4, 321, 9, 321, 4, 322, 9, 322, 4, 323, 9, 323, 4, 324, 9, 324, 4, 325, 9, 325, 4, 326, 9, 326, 4, 327, 9, 327, 4, 328, 9, 328, 4, 329, 9, 329, 4, 330, 9, 330, 4, 331, 9, 331, 4, 332, 9, 332, 4, 333, 9, 333, 4, 334, 9, 334, 4, 335, 9, 335, 4, 336, 9, 336, 4, 337, 9, 337, 4, 338, 9, 338, 4, 339, 9, 339, 4, 340, 9, 340, 4, 341, 9, 341, 4, 342, 9, 342, 4, 343, 9, 343, 4, 344, 9, 344, 4, 345, 9, 345, 4, 346, 9, 346, 4, 347, 9, 347, 4, 348, 9, 348, 4, 349, 9, 349, 4, 350, 9, 350, 4, 351, 9, 351, 4, 352, 9, 352, 4, 353, 9, 353, 4, 354, 9, 354, 4, 355, 9, 355, 4, 356, 9, 356, 4, 357, 9, 357, 4, 358, 9, 358, 4, 359, 9, 359, 4, 360, 9, 360, 4, 361, 9, 361, 4, 362, 9, 362, 4, 363, 9, 363, 4, 364, 9, 364, 4, 365, 9, 365, 4, 366, 9, 366, 4, 367, 9, 367, 4, 368, 9, 368, 4, 369, 9, 369, 4, 370, 9, 370, 4, 371, 9, 371, 4, 372, 9, 372, 4, 373, 9, 373, 4, 374, 9, 374, 4, 375, 9, 375, 4, 376, 9, 376, 4, 377, 9, 377, 4, 378, 9, 378, 4, 379, 9, 379, 4, 380, 9, 380, 4, 381, 9, 381, 4, 382, 9, 382, 4, 383, 9, 383, 4, 384, 9, 384, 4, 385, 9, 385, 4, 386, 9, 386, 4, 387, 9, 387, 4, 388, 9, 388, 4, 389, 9, 389, 4, 390, 9, 390, 4, 391, 9, 391, 4, 392, 9, 392, 4, 393, 9, 393, 4, 394, 9, 394, 4, 395, 9, 395, 4, 396, 9, 396, 4, 397, 9, 397, 4, 398, 9, 398, 4, 399, 9, 399, 4, 400, 9, 400, 4, 401, 9, 401, 4, 402, 9, 402, 4, 403, 9, 403, 4, 404, 9, 404, 4, 405, 9, 405, 4, 406, 9, 406, 4, 407, 9, 407, 4, 408, 9, 408, 4, 409, 9, 409, 4, 410, 9, 410, 4, 411, 9, 411, 4, 412, 9, 412, 4, 413, 9, 413, 4, 414, 9, 414, 4, 415, 9, 415, 4, 416, 9, 416, 4, 417, 9, 417, 4, 418, 9, 418, 4, 419, 9, 419, 4, 420, 9, 420, 4, 421, 9, 421, 4, 422, 9, 422, 4, 423, 9, 423, 4, 424, 9, 424, 4, 425, 9, 425, 4, 426, 9, 426, 4, 427, 9, 427, 4, 428, 9, 428, 4, 429, 9, 429, 4, 430, 9, 430, 4, 431, 9, 431, 4, 432, 9, 432, 4, 433, 9, 433, 4, 434, 9, 434, 4, 435, 9, 435, 4, 436, 9, 436, 4, 437, 9, 437, 4, 438, 9, 438, 4, 439, 9, 439, 4, 440, 9, 440, 4, 441, 9, 441, 4, 442, 9, 442, 4, 443, 9, 443, 4, 444, 9, 444, 4, 445, 9, 445, 4, 446, 9, 446, 4, 447, 9, 447, 4, 448, 9, 448, 4, 449, 9, 449, 4, 450, 9, 450, 4, 451, 9, 451, 4, 452, 9, 452, 4, 453, 9, 453, 4, 454, 9, 454, 4, 455, 9, 455, 4, 456, 9, 456, 4, 457, 9, 457, 4, 458, 9, 458, 4, 459, 9, 459, 4, 460, 9, 460, 4, 461, 9, 461, 4, 462, 9, 462, 4, 463, 9, 463, 4, 464, 9, 464, 4, 465, 9, 465, 4, 466, 9, 466, 4, 467, 9, 467, 4, 468, 9, 468, 4, 469, 9, 469, 4, 470, 9, 470, 4, 471, 9, 471, 4, 472, 9, 472, 4, 473, 9, 473, 4, 474, 9, 474, 4, 475, 9, 475, 4, 476, 9, 476, 4, 477, 9, 477, 4, 478, 9, 478, 4, 479, 9, 479, 4, 480, 9, 480, 4, 481, 9, 481, 4, 482, 9, 482, 4, 483, 9, 483, 4, 484, 9, 484, 4, 485, 9, 485, 4, 486, 9, 486, 4, 487, 9, 487, 4, 488, 9, 488, 4, 489, 9, 489, 4, 490, 9, 490, 4, 491, 9, 491, 4, 492, 9, 492, 4, 493, 9, 493, 4, 494, 9, 494, 4, 495, 9, 495, 4, 496, 9, 496, 4, 497, 9, 497, 4, 498, 9, 498, 4, 499, 9, 499, 4, 500, 9, 500, 4, 501, 9, 501, 4, 502, 9, 502, 4, 503, 9, 503, 4, 504, 9, 504, 4, 505, 9, 505, 4, 506, 9, 506, 4, 507, 9, 507, 4, 508, 9, 508, 4, 509, 9, 509, 4, 510, 9, 510, 4, 511, 9, 511, 4, 512, 9, 512, 4, 513, 9, 513, 4, 514, 9, 514, 4, 515, 9, 515, 4, 516, 9, 516, 4, 517, 9, 517, 4, 518, 9, 518, 4, 519, 9, 519, 4, 520, 9, 520, 4, 521, 9, 521, 4, 522, 9, 522, 4, 523, 9, 523, 4, 524, 9, 524, 4, 525, 9, 525, 4, 526, 9, 526, 4, 527, 9, 527, 4, 528, 9, 528, 4, 529, 9, 529, 4, 530, 9, 530, 4, 531, 9, 531, 4, 532, 9, 532, 4, 533, 9, 533, 4, 534, 9, 534, 4, 535, 9, 535, 4, 536, 9, 536, 4, 537, 9, 537, 4, 538, 9, 538, 4, 539, 9, 539, 4, 540, 9, 540, 4, 541, 9, 541, 4, 542, 9, 542, 4, 543, 9, 543, 4, 544, 9, 544, 4, 545, 9, 545, 4, 546, 9, 546, 4, 547, 9, 547, 4, 548, 9, 548, 4, 549, 9, 549, 4, 550, 9, 550, 4, 551, 9, 551, 4, 552, 9, 552, 4, 553, 9, 553, 4, 554, 9, 554, 4, 555, 9, 555, 4, 556, 9, 556, 4, 557, 9, 557, 4, 558, 9, 558, 4, 559, 9, 559, 4, 560, 9, 560, 4, 561, 9, 561, 4, 562, 9, 562, 4, 563, 9, 563, 4, 564, 9, 564, 4, 565, 9, 565, 4, 566, 9, 566, 4, 567, 9, 567, 4, 568, 9, 568, 4, 569, 9, 569, 4, 570, 9, 570, 4, 571, 9, 571, 4, 572, 9, 572, 4, 573, 9, 573, 4, 574, 9, 574, 4, 575, 9, 575, 4, 576, 9, 576, 4, 577, 9, 577, 4, 578, 9, 578, 4, 579, 9, 579, 4, 580, 9, 580, 4, 581, 9, 581, 4, 582, 9, 582, 4, 583, 9, 583, 4, 584, 9, 584, 4, 585, 9, 585, 4, 586, 9, 586, 4, 587, 9, 587, 4, 588, 9, 588, 4, 589, 9, 589, 4, 590, 9, 590, 4, 591, 9, 591, 4, 592, 9, 592, 4, 593, 9, 593, 4, 594, 9, 594, 4, 595, 9, 595, 4, 596, 9, 596, 4, 597, 9, 597, 4, 598, 9, 598, 4, 599, 9, 599, 4, 600, 9, 600, 4, 601, 9, 601, 4, 602, 9, 602, 4, 603, 9, 603, 4, 604, 9, 604, 4, 605, 9, 605, 4, 606, 9, 606, 4, 607, 9, 607, 4, 608, 9, 608, 4, 609, 9, 609, 4, 610, 9, 610, 4, 611, 9, 611, 4, 612, 9, 612, 4, 613, 9, 613, 4, 614, 9, 614, 4, 615, 9, 615, 4, 616, 9, 616, 4, 617, 9, 617, 4, 618, 9, 618, 4, 619, 9, 619, 4, 620, 9, 620, 4, 621, 9, 621, 4, 622, 9, 622, 4, 623, 9, 623, 4, 624, 9, 624, 4, 625, 9, 625, 4, 626, 9, 626, 4, 627, 9, 627, 4, 628, 9, 628, 4, 629, 9, 629, 4, 630, 9, 630, 4, 631, 9, 631, 4, 632, 9, 632, 4, 633, 9, 633, 4, 634, 9, 634, 4, 635, 9, 635, 4, 636, 9, 636, 4, 637, 9, 637, 4, 638, 9, 638, 4, 639, 9, 639, 4, 640, 9, 640, 4, 641, 9, 641, 4, 642, 9, 642, 4, 643, 9, 643, 4, 644, 9, 644, 4, 645, 9, 645, 4, 646, 9, 646, 4, 647, 9, 647, 4, 648, 9, 648, 4, 649, 9, 649, 4, 650, 9, 650, 4, 651, 9, 651, 4, 652, 9, 652, 4, 653, 9, 653, 4, 654, 9, 654, 4, 655, 9, 655, 4, 656, 9, 656, 4, 657, 9, 657, 4, 658, 9, 658, 4, 659, 9, 659, 4, 660, 9, 660, 4, 661, 9, 661, 4, 662, 9, 662, 4, 663, 9, 663, 4, 664, 9, 664, 4, 665, 9, 665, 4, 666, 9, 666, 4, 667, 9, 667, 4, 668, 9, 668, 4, 669, 9, 669, 4, 670, 9, 670, 4, 671, 9, 671, 4, 672, 9, 672, 4, 673, 9, 673, 4, 674, 9, 674, 4, 675, 9, 675, 4, 676, 9, 676, 4, 677, 9, 677, 4, 678, 9, 678, 4, 679, 9, 679, 4, 680, 9, 680, 4, 681, 9, 681, 4, 682, 9, 682, 4, 683, 9, 683, 4, 684, 9, 684, 4, 685, 9, 685, 4, 686, 9, 686, 4, 687, 9, 687, 4, 688, 9, 688, 4, 689, 9, 689, 4, 690, 9, 690, 4, 691, 9, 691, 4, 692, 9, 692, 4, 693, 9, 693, 4, 694, 9, 694, 4, 695, 9, 695, 4, 696, 9, 696, 4, 697, 9, 697, 4, 698, 9, 698, 4, 699, 9, 699, 4, 700, 9, 700, 4, 701, 9, 701, 4, 702, 9, 702, 4, 703, 9, 703, 4, 704, 9, 704, 4, 705, 9, 705, 4, 706, 9, 706, 4, 707, 9, 707, 4, 708, 9, 708, 4, 709, 9, 709, 4, 710, 9, 710, 4, 711, 9, 711, 4, 712, 9, 712, 4, 713, 9, 713, 4, 714, 9, 714, 4, 715, 9, 715, 4, 716, 9, 716, 4, 717, 9, 717, 4, 718, 9, 718, 4, 719, 9, 719, 4, 720, 9, 720, 4, 721, 9, 721, 4, 722, 9, 722, 4, 723, 9, 723, 4, 724, 9, 724, 4, 725, 9, 725, 4, 726, 9, 726, 4, 727, 9, 727, 4, 728, 9, 728, 4, 729, 9, 729, 4, 730, 9, 730, 4, 731, 9, 731, 4, 732, 9, 732, 4, 733, 9, 733, 4, 734, 9, 734, 4, 735, 9, 735, 4, 736, 9, 736, 4, 737, 9, 737, 4, 738, 9, 738, 4, 739, 9, 739, 4, 740, 9, 740, 4, 741, 9, 741, 4, 742, 9, 742, 4, 743, 9, 743, 4, 744, 9, 744, 4, 745, 9, 745, 4, 746, 9, 746, 4, 747, 9, 747, 4, 748, 9, 748, 4, 749, 9, 749, 4, 750, 9, 750, 4, 751, 9, 751, 4, 752, 9, 752, 4, 753, 9, 753, 4, 754, 9, 754, 4, 755, 9, 755, 4, 756, 9, 756, 4, 757, 9, 757, 4, 758, 9, 758, 4, 759, 9, 759, 4, 760, 9, 760, 4, 761, 9, 761, 4, 762, 9, 762, 4, 763, 9, 763, 4, 764, 9, 764, 4, 765, 9, 765, 4, 766, 9, 766, 4, 767, 9, 767, 4, 768, 9, 768, 4, 769, 9, 769, 4, 770, 9, 770, 4, 771, 9, 771, 4, 772, 9, 772, 4, 773, 9, 773, 4, 774, 9, 774, 4, 775, 9, 775, 4, 776, 9, 776, 4, 777, 9, 777, 4, 778, 9, 778, 4, 779, 9, 779, 4, 780, 9, 780, 4, 781, 9, 781, 4, 782, 9, 782, 4, 783, 9, 783, 4, 784, 9, 784, 4, 785, 9, 785, 4, 786, 9, 786, 4, 787, 9, 787, 4, 788, 9, 788, 4, 789, 9, 789, 4, 790, 9, 790, 4, 791, 9, 791, 4, 792, 9, 792, 4, 793, 9, 793, 4, 794, 9, 794, 4, 795, 9, 795, 4, 796, 9, 796, 4, 797, 9, 797, 4, 798, 9, 798, 4, 799, 9, 799, 4, 800, 9, 800, 4, 801, 9, 801, 4, 802, 9, 802, 4, 803, 9, 803, 4, 804, 9, 804, 4, 805, 9, 805, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 3, 5, 5, 5, 1620, 10, 5, 7, 5, 1622, 10, 5, 12, 5, 14, 5, 1625, 11, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 5, 6, 1751, 10, 6, 3, 7, 3, 7, 5, 7, 1755, 10, 7, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 5, 10, 1768, 10, 10, 3, 11, 7, 11, 1771, 10, 11, 12, 11, 14, 11, 1774, 11, 11, 3, 12, 7, 12, 1777, 10, 12, 12, 12, 14, 12, 1780, 11, 12, 3, 13, 3, 13, 3, 13, 5, 13, 1785, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 1800, 10, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 5, 14, 1812, 10, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 1830, 10, 17, 3, 18, 3, 18, 3, 18, 5, 18, 1835, 10, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 1845, 10, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 1869, 10, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 1876, 10, 23, 3, 23, 3, 23, 3, 24, 3, 24, 5, 24, 1882, 10, 24, 3, 25, 7, 25, 1885, 10, 25, 12, 25, 14, 25, 1888, 11, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 5, 26, 1896, 10, 26, 3, 27, 3, 27, 5, 27, 1900, 10, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 5, 28, 1912, 10, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 5, 30, 1943, 10, 30, 3, 31, 3, 31, 3, 31, 7, 31, 1948, 10, 31, 12, 31, 14, 31, 1951, 11, 31, 3, 32, 3, 32, 3, 32, 7, 32, 1956, 10, 32, 12, 32, 14, 32, 1959, 11, 32, 3, 33, 3, 33, 5, 33, 1963, 10, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 5, 34, 1970, 10, 34, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 1976, 10, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 1993, 10, 36, 3, 37, 3, 37, 3, 37, 5, 37, 1998, 10, 37, 3, 38, 3, 38, 5, 38, 2002, 10, 38, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 2015, 10, 40, 3, 41, 3, 41, 5, 41, 2019, 10, 41, 3, 42, 3, 42, 3, 42, 5, 42, 2024, 10, 42, 3, 43, 3, 43, 3, 43, 5, 43, 2029, 10, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 2041, 10, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 5, 46, 2050, 10, 46, 3, 47, 3, 47, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2063, 10, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2068, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2079, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2090, 10, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2095, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2106, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2117, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2126, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2136, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2151, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2163, 10, 50, 3, 50, 3, 50, 3, 50, 5, 50, 2168, 10, 50, 3, 51, 3, 51, 3, 51, 7, 51, 2173, 10, 51, 12, 51, 14, 51, 2176, 11, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 5, 52, 2186, 10, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 5, 54, 2444, 10, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 5, 55, 2451, 10, 55, 3, 56, 3, 56, 3, 56, 5, 56, 2456, 10, 56, 3, 57, 3, 57, 3, 57, 5, 57, 2461, 10, 57, 3, 58, 3, 58, 3, 58, 5, 58, 2466, 10, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 5, 59, 2474, 10, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 5, 61, 2483, 10, 61, 3, 62, 3, 62, 3, 62, 7, 62, 2488, 10, 62, 12, 62, 14, 62, 2491, 11, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 2500, 10, 63, 5, 63, 2502, 10, 63, 3, 64, 6, 64, 2505, 10, 64, 13, 64, 14, 64, 2506, 3, 65, 3, 65, 3, 65, 3, 65, 5, 65, 2513, 10, 65, 3, 65, 3, 65, 3, 65, 3, 65, 5, 65, 2519, 10, 65, 5, 65, 2521, 10, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 5, 66, 2549, 10, 66, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 7, 68, 2557, 10, 68, 12, 68, 14, 68, 2560, 11, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 7, 70, 2570, 10, 70, 12, 70, 14, 70, 2573, 11, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 5, 71, 2584, 10, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 5, 71, 2598, 10, 71, 3, 72, 3, 72, 3, 72, 5, 72, 2603, 10, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 5, 73, 2627, 10, 73, 3, 74, 3, 74, 3, 75, 3, 75, 5, 75, 2633, 10, 75, 3, 76, 3, 76, 3, 76, 5, 76, 2638, 10, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 5, 77, 2645, 10, 77, 3, 78, 7, 78, 2648, 10, 78, 12, 78, 14, 78, 2651, 11, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 5, 79, 2688, 10, 79, 3, 80, 3, 80, 5, 80, 2692, 10, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 2699, 10, 81, 3, 82, 3, 82, 5, 82, 2703, 10, 82, 3, 83, 3, 83, 3, 83, 7, 83, 2708, 10, 83, 12, 83, 14, 83, 2711, 11, 83, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 5, 85, 2724, 10, 85, 3, 86, 3, 86, 3, 86, 7, 86, 2729, 10, 86, 12, 86, 14, 86, 2732, 11, 86, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 5, 88, 2742, 10, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 5, 88, 2775, 10, 88, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 3, 89, 5, 89, 2785, 10, 89, 3, 90, 3, 90, 5, 90, 2789, 10, 90, 3, 91, 3, 91, 3, 91, 3, 91, 3, 91, 5, 91, 2796, 10, 91, 3, 92, 3, 92, 3, 92, 7, 92, 2801, 10, 92, 12, 92, 14, 92, 2804, 11, 92, 3, 93, 3, 93, 3, 93, 7, 93, 2809, 10, 93, 12, 93, 14, 93, 2812, 11, 93, 3, 94, 3, 94, 3, 94, 5, 94, 2817, 10, 94, 3, 95, 3, 95, 5, 95, 2821, 10, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 5, 97, 2831, 10, 97, 3, 97, 3, 97, 3, 98, 7, 98, 2836, 10, 98, 12, 98, 14, 98, 2839, 11, 98, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 5, 99, 2849, 10, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 5, 100, 2881, 10, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 5, 100, 2889, 10, 100, 3, 101, 3, 101, 3, 101, 5, 101, 2894, 10, 101, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 5, 102, 2901, 10, 102, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 7, 104, 2909, 10, 104, 12, 104, 14, 104, 2912, 11, 104, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 2921, 10, 106, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 5, 107, 2941, 10, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 5, 107, 2956, 10, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 5, 107, 2981, 10, 107, 3, 108, 3, 108, 3, 108, 5, 108, 2986, 10, 108, 3, 109, 3, 109, 3, 109, 3, 109, 3, 109, 5, 109, 2993, 10, 109, 3, 110, 3, 110, 3, 110, 7, 110, 2998, 10, 110, 12, 110, 14, 110, 3001, 11, 110, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 5, 112, 3011, 10, 112, 3, 113, 3, 113, 3, 113, 5, 113, 3016, 10, 113, 3, 114, 3, 114, 3, 114, 7, 114, 3021, 10, 114, 12, 114, 14, 114, 3024, 11, 114, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 3034, 10, 115, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 5, 116, 3042, 10, 116, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 5, 117, 3053, 10, 117, 3, 118, 3, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 5, 120, 3069, 10, 120, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 5, 121, 3077, 10, 121, 3, 122, 3, 122, 5, 122, 3081, 10, 122, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 7, 124, 3093, 10, 124, 12, 124, 14, 124, 3096, 11, 124, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 3, 125, 5, 125, 3112, 10, 125, 3, 126, 3, 126, 3, 126, 5, 126, 3117, 10, 126, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 5, 127, 3124, 10, 127, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 5, 128, 3133, 10, 128, 3, 128, 5, 128, 3136, 10, 128, 3, 129, 3, 129, 3, 129, 5, 129, 3141, 10, 129, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 5, 130, 3148, 10, 130, 3, 131, 3, 131, 3, 131, 3, 131, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 5, 132, 3159, 10, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 133, 3, 133, 3, 133, 3, 133, 5, 133, 3172, 10, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 5, 134, 3185, 10, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 136, 3, 136, 3, 136, 3, 136, 5, 136, 3203, 10, 136, 3, 136, 5, 136, 3206, 10, 136, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 5, 137, 3215, 10, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 137, 3, 138, 3, 138, 3, 138, 3, 138, 3, 138, 3, 138, 3, 139, 3, 139, 5, 139, 3230, 10, 139, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 140, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 3, 141, 5, 141, 3245, 10, 141, 3, 141, 3, 141, 3, 141, 3, 142, 3, 142, 3, 142, 3, 142, 5, 142, 3254, 10, 142, 3, 142, 3, 142, 3, 142, 3, 143, 3, 143, 5, 143, 3261, 10, 143, 3, 144, 3, 144, 3, 144, 3, 144, 3, 144, 5, 144, 3268, 10, 144, 3, 145, 6, 145, 3271, 10, 145, 13, 145, 14, 145, 3272, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 5, 146, 3303, 10, 146, 5, 146, 3305, 10, 146, 3, 147, 3, 147, 5, 147, 3309, 10, 147, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 5, 148, 3317, 10, 148, 3, 149, 3, 149, 3, 149, 7, 149, 3322, 10, 149, 12, 149, 14, 149, 3325, 11, 149, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 3, 150, 5, 150, 3338, 10, 150, 3, 151, 3, 151, 5, 151, 3342, 10, 151, 3, 152, 3, 152, 5, 152, 3346, 10, 152, 3, 153, 3, 153, 3, 153, 5, 153, 3351, 10, 153, 3, 154, 3, 154, 3, 154, 3, 154, 5, 154, 3357, 10, 154, 3, 155, 3, 155, 5, 155, 3361, 10, 155, 3, 156, 3, 156, 5, 156, 3365, 10, 156, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 157, 3, 158, 3, 158, 3, 158, 5, 158, 3378, 10, 158, 3, 159, 3, 159, 3, 159, 3, 159, 5, 159, 3384, 10, 159, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 160, 3, 160, 5, 160, 3393, 10, 160, 3, 160, 3, 160, 3, 160, 3, 160, 3, 161, 7, 161, 3400, 10, 161, 12, 161, 14, 161, 3403, 11, 161, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 5, 162, 3412, 10, 162, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 164, 7, 164, 3421, 10, 164, 12, 164, 14, 164, 3424, 11, 164, 3, 165, 3, 165, 3, 165, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 5, 166, 3533, 10, 166, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 5, 168, 3551, 10, 168, 3, 169, 6, 169, 3554, 10, 169, 13, 169, 14, 169, 3555, 3, 170, 3, 170, 5, 170, 3560, 10, 170, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 5, 171, 3577, 10, 171, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 5, 172, 3585, 10, 172, 3, 173, 3, 173, 3, 173, 7, 173, 3590, 10, 173, 12, 173, 14, 173, 3593, 11, 173, 3, 174, 3, 174, 3, 174, 3, 174, 3, 174, 3, 175, 3, 175, 3, 175, 7, 175, 3603, 10, 175, 12, 175, 14, 175, 3606, 11, 175, 3, 176, 3, 176, 3, 176, 3, 176, 3, 176, 3, 176, 3, 176, 5, 176, 3615, 10, 176, 3, 177, 3, 177, 3, 177, 3, 178, 3, 178, 3, 179, 3, 179, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 5, 180, 3649, 10, 180, 3, 181, 3, 181, 3, 181, 5, 181, 3654, 10, 181, 3, 182, 3, 182, 3, 182, 5, 182, 3659, 10, 182, 3, 183, 3, 183, 5, 183, 3663, 10, 183, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 5, 184, 3671, 10, 184, 5, 184, 3673, 10, 184, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 5, 185, 3731, 10, 185, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 187, 3, 187, 3, 187, 5, 187, 3748, 10, 187, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 5, 188, 3756, 10, 188, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 5, 189, 3779, 10, 189, 3, 190, 3, 190, 5, 190, 3783, 10, 190, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 5, 191, 3803, 10, 191, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 5, 195, 3840, 10, 195, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 5, 196, 3849, 10, 196, 3, 197, 3, 197, 3, 197, 5, 197, 3854, 10, 197, 3, 198, 3, 198, 3, 198, 5, 198, 3859, 10, 198, 3, 199, 3, 199, 3, 199, 5, 199, 3864, 10, 199, 3, 200, 3, 200, 3, 200, 5, 200, 3869, 10, 200, 3, 201, 3, 201, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 202, 3, 203, 3, 203, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 3, 204, 5, 204, 3922, 10, 204, 3, 205, 3, 205, 3, 205, 3, 205, 5, 205, 3928, 10, 205, 3, 206, 3, 206, 3, 206, 7, 206, 3933, 10, 206, 12, 206, 14, 206, 3936, 11, 206, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 3, 207, 5, 207, 3945, 10, 207, 3, 208, 3, 208, 3, 208, 5, 208, 3950, 10, 208, 3, 209, 6, 209, 3953, 10, 209, 13, 209, 14, 209, 3954, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 211, 3, 211, 3, 212, 3, 212, 3, 213, 3, 213, 3, 214, 3, 214, 3, 214, 3, 214, 3, 214, 5, 214, 3973, 10, 214, 3, 215, 3, 215, 5, 215, 3977, 10, 215, 3, 216, 3, 216, 3, 217, 3, 217, 3, 217, 3, 217, 3, 217, 3, 217, 5, 217, 3987, 10, 217, 3, 218, 3, 218, 3, 219, 3, 219, 5, 219, 3993, 10, 219, 3, 219, 3, 219, 7, 219, 3997, 10, 219, 12, 219, 14, 219, 4000, 11, 219, 3, 220, 3, 220, 3, 220, 3, 220, 5, 220, 4006, 10, 220, 3, 221, 3, 221, 3, 221, 5, 221, 4011, 10, 221, 3, 222, 7, 222, 4014, 10, 222, 12, 222, 14, 222, 4017, 11, 222, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 5, 223, 4030, 10, 223, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 3, 224, 5, 224, 4058, 10, 224, 3, 225, 3, 225, 3, 225, 7, 225, 4063, 10, 225, 12, 225, 14, 225, 4066, 11, 225, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 227, 3, 227, 3, 227, 7, 227, 4077, 10, 227, 12, 227, 14, 227, 4080, 11, 227, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 5, 229, 4094, 10, 229, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 3, 231, 5, 231, 4211, 10, 231, 3, 232, 3, 232, 3, 232, 3, 232, 3, 233, 3, 233, 3, 233, 7, 233, 4220, 10, 233, 12, 233, 14, 233, 4223, 11, 233, 3, 234, 3, 234, 3, 234, 5, 234, 4228, 10, 234, 3, 235, 3, 235, 3, 235, 3, 235, 3, 235, 3, 235, 5, 235, 4236, 10, 235, 3, 236, 3, 236, 3, 236, 3, 236, 3, 237, 3, 237, 3, 237, 7, 237, 4245, 10, 237, 12, 237, 14, 237, 4248, 11, 237, 3, 238, 3, 238, 3, 238, 3, 238, 3, 239, 3, 239, 5, 239, 4256, 10, 239, 3, 240, 3, 240, 3, 240, 7, 240, 4261, 10, 240, 12, 240, 14, 240, 4264, 11, 240, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 5, 241, 4303, 10, 241, 3, 242, 3, 242, 3, 242, 3, 242, 5, 242, 4309, 10, 242, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 243, 3, 244, 3, 244, 3, 244, 7, 244, 4328, 10, 244, 12, 244, 14, 244, 4331, 11, 244, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 3, 245, 5, 245, 4358, 10, 245, 3, 246, 3, 246, 5, 246, 4362, 10, 246, 3, 247, 3, 247, 3, 247, 5, 247, 4367, 10, 247, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 5, 248, 4376, 10, 248, 3, 249, 3, 249, 5, 249, 4380, 10, 249, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 5, 251, 4407, 10, 251, 3, 252, 3, 252, 3, 252, 7, 252, 4412, 10, 252, 12, 252, 14, 252, 4415, 11, 252, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 5, 253, 4429, 10, 253, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 5, 254, 4449, 10, 254, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 5, 255, 4469, 10, 255, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 5, 258, 4562, 10, 258, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 5, 259, 4587, 10, 259, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 5, 260, 4594, 10, 260, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4610, 10, 261, 3, 262, 3, 262, 3, 263, 3, 263, 3, 263, 7, 263, 4617, 10, 263, 12, 263, 14, 263, 4620, 11, 263, 3, 264, 3, 264, 5, 264, 4624, 10, 264, 3, 265, 3, 265, 6, 265, 4628, 10, 265, 13, 265, 14, 265, 4629, 3, 266, 3, 266, 3, 266, 7, 266, 4635, 10, 266, 12, 266, 14, 266, 4638, 11, 266, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 267, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 5, 268, 4651, 10, 268, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 3, 269, 5, 269, 4800, 10, 269, 3, 270, 3, 270, 5, 270, 4804, 10, 270, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 271, 5, 271, 4897, 10, 271, 3, 272, 3, 272, 3, 272, 5, 272, 4902, 10, 272, 3, 273, 3, 273, 5, 273, 4906, 10, 273, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 4912, 10, 274, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 3, 275, 5, 275, 4980, 10, 275, 3, 276, 3, 276, 3, 277, 3, 277, 5, 277, 4986, 10, 277, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 3, 279, 5, 279, 5015, 10, 279, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 3, 280, 5, 280, 5032, 10, 280, 3, 281, 3, 281, 3, 281, 7, 281, 5037, 10, 281, 12, 281, 14, 281, 5040, 11, 281, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 5, 282, 5051, 10, 282, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 3, 283, 5, 283, 5111, 10, 283, 3, 284, 3, 284, 3, 284, 7, 284, 5116, 10, 284, 12, 284, 14, 284, 5119, 11, 284, 3, 285, 3, 285, 3, 285, 5, 285, 5124, 10, 285, 3, 286, 3, 286, 3, 286, 3, 286, 5, 286, 5130, 10, 286, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 5, 288, 5156, 10, 288, 3, 289, 3, 289, 3, 289, 3, 289, 5, 289, 5162, 10, 289, 3, 290, 3, 290, 3, 290, 3, 290, 5, 290, 5168, 10, 290, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 291, 3, 292, 7, 292, 5177, 10, 292, 12, 292, 14, 292, 5180, 11, 292, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 5, 293, 5191, 10, 293, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 3, 294, 5, 294, 5220, 10, 294, 3, 295, 3, 295, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 5, 296, 5259, 10, 296, 3, 297, 3, 297, 5, 297, 5263, 10, 297, 3, 298, 3, 298, 5, 298, 5267, 10, 298, 3, 299, 3, 299, 5, 299, 5271, 10, 299, 3, 300, 3, 300, 3, 300, 5, 300, 5276, 10, 300, 3, 301, 3, 301, 3, 301, 7, 301, 5281, 10, 301, 12, 301, 14, 301, 5284, 11, 301, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 3, 302, 5, 302, 5297, 10, 302, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 5, 303, 5310, 10, 303, 3, 304, 3, 304, 3, 304, 3, 304, 3, 304, 3, 304, 5, 304, 5318, 10, 304, 3, 305, 3, 305, 3, 305, 7, 305, 5323, 10, 305, 12, 305, 14, 305, 5326, 11, 305, 3, 306, 3, 306, 3, 306, 5, 306, 5331, 10, 306, 3, 307, 3, 307, 5, 307, 5335, 10, 307, 3, 308, 3, 308, 3, 308, 5, 308, 5340, 10, 308, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 5, 309, 5347, 10, 309, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 3, 310, 5, 310, 5361, 10, 310, 5, 310, 5363, 10, 310, 3, 310, 3, 310, 3, 311, 3, 311, 3, 311, 5, 311, 5370, 10, 311, 3, 312, 3, 312, 5, 312, 5374, 10, 312, 3, 312, 3, 312, 3, 313, 3, 313, 3, 313, 7, 313, 5381, 10, 313, 12, 313, 14, 313, 5384, 11, 313, 3, 314, 3, 314, 3, 314, 7, 314, 5389, 10, 314, 12, 314, 14, 314, 5392, 11, 314, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 5, 315, 5400, 10, 315, 5, 315, 5402, 10, 315, 3, 316, 3, 316, 5, 316, 5406, 10, 316, 3, 316, 3, 316, 3, 317, 3, 317, 3, 317, 7, 317, 5413, 10, 317, 12, 317, 14, 317, 5416, 11, 317, 3, 318, 3, 318, 5, 318, 5420, 10, 318, 3, 318, 3, 318, 3, 318, 3, 318, 5, 318, 5426, 10, 318, 3, 318, 3, 318, 3, 318, 5, 318, 5431, 10, 318, 3, 319, 3, 319, 5, 319, 5435, 10, 319, 3, 319, 3, 319, 3, 319, 5, 319, 5440, 10, 319, 3, 320, 3, 320, 3, 321, 3, 321, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 3, 322, 5, 322, 5458, 10, 322, 3, 323, 3, 323, 3, 323, 5, 323, 5463, 10, 323, 3, 324, 3, 324, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 3, 325, 5, 325, 5478, 10, 325, 3, 325, 3, 325, 3, 326, 3, 326, 3, 326, 7, 326, 5485, 10, 326, 12, 326, 14, 326, 5488, 11, 326, 3, 327, 3, 327, 3, 327, 3, 328, 3, 328, 3, 328, 7, 328, 5496, 10, 328, 12, 328, 14, 328, 5499, 11, 328, 3, 329, 6, 329, 5502, 10, 329, 13, 329, 14, 329, 5503, 3, 329, 3, 329, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 5, 330, 5543, 10, 330, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 5, 331, 5553, 10, 331, 3, 332, 3, 332, 3, 332, 3, 332, 3, 332, 5, 332, 5560, 10, 332, 3, 333, 3, 333, 3, 333, 3, 333, 3, 333, 3, 333, 3, 333, 7, 333, 5569, 10, 333, 12, 333, 14, 333, 5572, 11, 333, 3, 334, 3, 334, 3, 334, 5, 334, 5577, 10, 334, 3, 335, 3, 335, 3, 335, 3, 336, 3, 336, 3, 336, 7, 336, 5585, 10, 336, 12, 336, 14, 336, 5588, 11, 336, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 338, 6, 338, 5597, 10, 338, 13, 338, 14, 338, 5598, 3, 339, 3, 339, 5, 339, 5603, 10, 339, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 5, 340, 5641, 10, 340, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 5, 341, 5655, 10, 341, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 5, 342, 5669, 10, 342, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 5, 343, 5693, 10, 343, 3, 344, 3, 344, 3, 344, 7, 344, 5698, 10, 344, 12, 344, 14, 344, 5701, 11, 344, 3, 344, 3, 344, 3, 345, 3, 345, 3, 345, 7, 345, 5708, 10, 345, 12, 345, 14, 345, 5711, 11, 345, 3, 346, 3, 346, 3, 346, 3, 347, 3, 347, 3, 347, 3, 348, 6, 348, 5720, 10, 348, 13, 348, 14, 348, 5721, 3, 349, 3, 349, 3, 349, 5, 349, 5727, 10, 349, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 3, 350, 5, 350, 5763, 10, 350, 3, 351, 3, 351, 3, 351, 3, 351, 3, 351, 5, 351, 5770, 10, 351, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 352, 3, 353, 3, 353, 3, 353, 5, 353, 5785, 10, 353, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 5, 355, 5832, 10, 355, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 3, 357, 5, 357, 5869, 10, 357, 3, 358, 3, 358, 3, 359, 3, 359, 3, 360, 3, 360, 3, 360, 7, 360, 5878, 10, 360, 12, 360, 14, 360, 5881, 11, 360, 3, 361, 3, 361, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 5, 362, 5897, 10, 362, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 5, 363, 6367, 10, 363, 3, 364, 3, 364, 5, 364, 6371, 10, 364, 3, 365, 3, 365, 3, 365, 5, 365, 6376, 10, 365, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 3, 366, 5, 366, 6435, 10, 366, 3, 367, 3, 367, 5, 367, 6439, 10, 367, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 5, 368, 6658, 10, 368, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 370, 3, 370, 3, 370, 7, 370, 6671, 10, 370, 12, 370, 14, 370, 6674, 11, 370, 3, 371, 3, 371, 3, 371, 3, 371, 3, 371, 3, 371, 3, 371, 3, 371, 5, 371, 6684, 10, 371, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 5, 372, 6691, 10, 372, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 3, 374, 5, 374, 6884, 10, 374, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 376, 3, 376, 5, 376, 6894, 10, 376, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 5, 377, 6902, 10, 377, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 5, 378, 6931, 10, 378, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 380, 3, 380, 3, 380, 7, 380, 6945, 10, 380, 12, 380, 14, 380, 6948, 11, 380, 3, 381, 3, 381, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 5, 382, 6989, 10, 382, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 5, 383, 7003, 10, 383, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 385, 3, 385, 3, 385, 3, 385, 3, 385, 3, 385, 5, 385, 7025, 10, 385, 3, 386, 3, 386, 3, 386, 7, 386, 7030, 10, 386, 12, 386, 14, 386, 7033, 11, 386, 3, 387, 3, 387, 3, 387, 3, 387, 3, 387, 5, 387, 7040, 10, 387, 3, 388, 3, 388, 5, 388, 7044, 10, 388, 3, 389, 3, 389, 3, 390, 3, 390, 3, 390, 5, 390, 7051, 10, 390, 3, 391, 3, 391, 3, 391, 3, 391, 3, 392, 3, 392, 3, 392, 5, 392, 7060, 10, 392, 3, 393, 3, 393, 3, 393, 3, 394, 3, 394, 3, 394, 3, 394, 5, 394, 7069, 10, 394, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 3, 395, 5, 395, 7121, 10, 395, 3, 396, 3, 396, 3, 396, 5, 396, 7126, 10, 396, 3, 397, 3, 397, 3, 397, 3, 397, 3, 397, 3, 397, 3, 397, 3, 397, 3, 397, 3, 397, 5, 397, 7138, 10, 397, 3, 398, 3, 398, 5, 398, 7142, 10, 398, 3, 398, 7, 398, 7145, 10, 398, 12, 398, 14, 398, 7148, 11, 398, 3, 399, 3, 399, 5, 399, 7152, 10, 399, 3, 400, 3, 400, 5, 400, 7156, 10, 400, 3, 400, 3, 400, 5, 400, 7160, 10, 400, 3, 401, 3, 401, 3, 401, 5, 401, 7165, 10, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 5, 401, 7181, 10, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 402, 3, 402, 5, 402, 7189, 10, 402, 3, 402, 3, 402, 3, 402, 5, 402, 7194, 10, 402, 3, 403, 3, 403, 3, 403, 3, 404, 3, 404, 3, 404, 3, 404, 3, 404, 3, 404, 3, 405, 3, 405, 5, 405, 7207, 10, 405, 3, 406, 6, 406, 7210, 10, 406, 13, 406, 14, 406, 7211, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 5, 407, 7219, 10, 407, 3, 408, 3, 408, 3, 408, 3, 408, 3, 408, 3, 408, 3, 408, 3, 408, 5, 408, 7229, 10, 408, 3, 409, 3, 409, 5, 409, 7233, 10, 409, 3, 410, 3, 410, 3, 410, 3, 410, 3, 410, 3, 410, 3, 410, 3, 410, 3, 410, 5, 410, 7244, 10, 410, 3, 411, 3, 411, 3, 411, 3, 411, 3, 411, 3, 412, 3, 412, 3, 412, 3, 412, 5, 412, 7255, 10, 412, 3, 412, 3, 412, 3, 412, 3, 412, 3, 412, 3, 412, 5, 412, 7263, 10, 412, 3, 413, 3, 413, 3, 413, 7, 413, 7268, 10, 413, 12, 413, 14, 413, 7271, 11, 413, 3, 414, 3, 414, 3, 415, 3, 415, 3, 415, 3, 415, 3, 415, 3, 415, 3, 416, 3, 416, 3, 416, 3, 416, 3, 416, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 5, 418, 7309, 10, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 5, 418, 7317, 10, 418, 3, 419, 3, 419, 5, 419, 7321, 10, 419, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 420, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 5, 421, 7402, 10, 421, 3, 422, 3, 422, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 423, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 3, 424, 5, 424, 7430, 10, 424, 3, 425, 3, 425, 3, 425, 5, 425, 7435, 10, 425, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 5, 426, 7450, 10, 426, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 5, 427, 7462, 10, 427, 3, 428, 3, 428, 3, 428, 7, 428, 7467, 10, 428, 12, 428, 14, 428, 7470, 11, 428, 3, 429, 3, 429, 3, 430, 3, 430, 3, 430, 3, 431, 3, 431, 5, 431, 7479, 10, 431, 3, 432, 3, 432, 3, 432, 5, 432, 7484, 10, 432, 3, 433, 3, 433, 5, 433, 7488, 10, 433, 3, 434, 3, 434, 5, 434, 7492, 10, 434, 3, 435, 3, 435, 5, 435, 7496, 10, 435, 3, 436, 3, 436, 5, 436, 7500, 10, 436, 3, 437, 3, 437, 3, 437, 3, 437, 3, 437, 5, 437, 7507, 10, 437, 3, 438, 3, 438, 3, 438, 3, 439, 3, 439, 3, 439, 7, 439, 7515, 10, 439, 12, 439, 14, 439, 7518, 11, 439, 3, 440, 3, 440, 5, 440, 7522, 10, 440, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 5, 441, 7540, 10, 441, 3, 442, 3, 442, 3, 442, 3, 442, 3, 442, 3, 442, 3, 442, 3, 442, 3, 442, 5, 442, 7551, 10, 442, 3, 443, 3, 443, 3, 443, 7, 443, 7556, 10, 443, 12, 443, 14, 443, 7559, 11, 443, 3, 444, 3, 444, 3, 444, 3, 445, 3, 445, 5, 445, 7566, 10, 445, 3, 446, 3, 446, 3, 446, 5, 446, 7571, 10, 446, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 5, 448, 7584, 10, 448, 3, 449, 3, 449, 3, 449, 3, 449, 5, 449, 7590, 10, 449, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 5, 450, 7619, 10, 450, 3, 451, 3, 451, 3, 451, 3, 451, 3, 451, 5, 451, 7626, 10, 451, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 5, 452, 7638, 10, 452, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 453, 3, 454, 3, 454, 3, 454, 5, 454, 7651, 10, 454, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 3, 455, 5, 455, 7666, 10, 455, 3, 455, 3, 455, 3, 455, 3, 455, 5, 455, 7672, 10, 455, 3, 456, 3, 456, 3, 457, 3, 457, 3, 457, 7, 457, 7679, 10, 457, 12, 457, 14, 457, 7682, 11, 457, 3, 458, 3, 458, 3, 458, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 5, 459, 7697, 10, 459, 3, 459, 5, 459, 7700, 10, 459, 3, 460, 3, 460, 3, 460, 3, 460, 3, 460, 3, 460, 3, 460, 3, 460, 3, 460, 5, 460, 7711, 10, 460, 3, 461, 3, 461, 3, 461, 5, 461, 7716, 10, 461, 3, 462, 3, 462, 3, 462, 3, 462, 3, 462, 3, 462, 3, 462, 3, 462, 3, 463, 3, 463, 3, 463, 5, 463, 7729, 10, 463, 3, 464, 3, 464, 3, 464, 3, 464, 3, 464, 3, 464, 3, 465, 3, 465, 3, 465, 3, 465, 3, 465, 5, 465, 7742, 10, 465, 3, 466, 3, 466, 3, 466, 3, 466, 3, 466, 3, 466, 3, 466, 3, 466, 3, 466, 5, 466, 7753, 10, 466, 3, 466, 5, 466, 7756, 10, 466, 3, 467, 3, 467, 5, 467, 7760, 10, 467, 3, 468, 3, 468, 3, 468, 3, 468, 5, 468, 7766, 10, 468, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 469, 3, 470, 3, 470, 3, 470, 7, 470, 7780, 10, 470, 12, 470, 14, 470, 7783, 11, 470, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 5, 471, 7795, 10, 471, 3, 472, 3, 472, 3, 472, 3, 473, 3, 473, 3, 473, 7, 473, 7803, 10, 473, 12, 473, 14, 473, 7806, 11, 473, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 475, 3, 475, 3, 476, 3, 476, 3, 476, 3, 476, 3, 476, 7, 476, 7823, 10, 476, 12, 476, 14, 476, 7826, 11, 476, 3, 477, 3, 477, 3, 477, 3, 477, 3, 477, 5, 477, 7833, 10, 477, 3, 478, 3, 478, 5, 478, 7837, 10, 478, 3, 479, 3, 479, 3, 479, 3, 479, 3, 479, 3, 479, 3, 479, 3, 479, 5, 479, 7847, 10, 479, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 5, 480, 7857, 10, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 5, 480, 7868, 10, 480, 5, 480, 7870, 10, 480, 3, 481, 3, 481, 5, 481, 7874, 10, 481, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 5, 482, 7884, 10, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 5, 482, 7900, 10, 482, 5, 482, 7902, 10, 482, 3, 482, 3, 482, 3, 482, 5, 482, 7907, 10, 482, 7, 482, 7909, 10, 482, 12, 482, 14, 482, 7912, 11, 482, 3, 483, 3, 483, 3, 483, 5, 483, 7917, 10, 483, 3, 484, 3, 484, 3, 484, 3, 485, 3, 485, 5, 485, 7924, 10, 485, 3, 485, 3, 485, 3, 486, 3, 486, 3, 486, 7, 486, 7931, 10, 486, 12, 486, 14, 486, 7934, 11, 486, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 487, 3, 488, 3, 488, 3, 488, 3, 488, 5, 488, 7948, 10, 488, 3, 489, 3, 489, 5, 489, 7952, 10, 489, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 5, 490, 7959, 10, 490, 3, 490, 5, 490, 7962, 10, 490, 3, 491, 3, 491, 5, 491, 7966, 10, 491, 3, 492, 5, 492, 7969, 10, 492, 3, 492, 3, 492, 3, 492, 3, 492, 3, 492, 3, 492, 3, 492, 3, 492, 3, 492, 3, 492, 3, 492, 5, 492, 7982, 10, 492, 3, 493, 3, 493, 5, 493, 7986, 10, 493, 3, 494, 3, 494, 3, 494, 5, 494, 7991, 10, 494, 3, 495, 3, 495, 3, 495, 3, 495, 3, 495, 3, 495, 5, 495, 7999, 10, 495, 3, 496, 3, 496, 5, 496, 8003, 10, 496, 3, 497, 3, 497, 5, 497, 8007, 10, 497, 3, 498, 3, 498, 3, 498, 3, 498, 3, 499, 3, 499, 3, 499, 7, 499, 8016, 10, 499, 12, 499, 14, 499, 8019, 11, 499, 3, 500, 3, 500, 3, 500, 3, 500, 5, 500, 8025, 10, 500, 3, 500, 3, 500, 3, 501, 3, 501, 5, 501, 8031, 10, 501, 3, 501, 3, 501, 5, 501, 8035, 10, 501, 5, 501, 8037, 10, 501, 3, 502, 3, 502, 5, 502, 8041, 10, 502, 3, 503, 3, 503, 3, 503, 3, 503, 5, 503, 8047, 10, 503, 3, 503, 3, 503, 3, 503, 3, 503, 3, 503, 3, 503, 3, 503, 5, 503, 8056, 10, 503, 3, 503, 3, 503, 3, 503, 3, 503, 5, 503, 8062, 10, 503, 5, 503, 8064, 10, 503, 5, 503, 8066, 10, 503, 3, 504, 3, 504, 3, 504, 3, 504, 3, 504, 5, 504, 8073, 10, 504, 3, 505, 3, 505, 5, 505, 8077, 10, 505, 3, 506, 3, 506, 3, 507, 3, 507, 3, 507, 3, 507, 3, 507, 5, 507, 8086, 10, 507, 3, 508, 3, 508, 5, 508, 8090, 10, 508, 3, 509, 3, 509, 3, 510, 3, 510, 3, 511, 3, 511, 3, 511, 3, 511, 5, 511, 8100, 10, 511, 3, 512, 3, 512, 3, 512, 7, 512, 8105, 10, 512, 12, 512, 14, 512, 8108, 11, 512, 3, 513, 3, 513, 3, 513, 3, 513, 3, 513, 5, 513, 8115, 10, 513, 3, 514, 3, 514, 3, 514, 3, 515, 3, 515, 3, 515, 3, 515, 3, 515, 3, 516, 3, 516, 3, 516, 3, 516, 3, 516, 3, 517, 3, 517, 3, 517, 3, 517, 3, 517, 3, 517, 3, 518, 3, 518, 3, 518, 5, 518, 8139, 10, 518, 3, 519, 3, 519, 3, 519, 3, 519, 5, 519, 8145, 10, 519, 3, 520, 3, 520, 5, 520, 8149, 10, 520, 3, 521, 6, 521, 8152, 10, 521, 13, 521, 14, 521, 8153, 3, 522, 3, 522, 3, 522, 3, 522, 3, 523, 3, 523, 3, 523, 5, 523, 8163, 10, 523, 3, 523, 3, 523, 5, 523, 8167, 10, 523, 3, 523, 5, 523, 8170, 10, 523, 3, 524, 3, 524, 3, 524, 5, 524, 8175, 10, 524, 3, 525, 3, 525, 3, 525, 3, 525, 3, 525, 3, 525, 3, 525, 3, 525, 3, 525, 7, 525, 8186, 10, 525, 12, 525, 14, 525, 8189, 11, 525, 3, 526, 3, 526, 3, 526, 5, 526, 8194, 10, 526, 3, 527, 3, 527, 3, 527, 7, 527, 8199, 10, 527, 12, 527, 14, 527, 8202, 11, 527, 3, 528, 3, 528, 3, 528, 5, 528, 8207, 10, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 5, 528, 8228, 10, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 5, 528, 8237, 10, 528, 3, 528, 3, 528, 3, 528, 5, 528, 8242, 10, 528, 3, 528, 3, 528, 3, 528, 3, 528, 5, 528, 8248, 10, 528, 3, 528, 3, 528, 3, 528, 5, 528, 8253, 10, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 5, 528, 8260, 10, 528, 3, 528, 3, 528, 3, 528, 5, 528, 8265, 10, 528, 3, 528, 3, 528, 3, 528, 3, 528, 7, 528, 8271, 10, 528, 12, 528, 14, 528, 8274, 11, 528, 3, 529, 5, 529, 8277, 10, 529, 3, 529, 3, 529, 3, 529, 3, 529, 3, 529, 5, 529, 8284, 10, 529, 3, 530, 3, 530, 5, 530, 8288, 10, 530, 3, 531, 3, 531, 3, 531, 5, 531, 8293, 10, 531, 3, 531, 5, 531, 8296, 10, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 5, 531, 8303, 10, 531, 3, 532, 3, 532, 5, 532, 8307, 10, 532, 3, 533, 3, 533, 3, 533, 3, 533, 3, 533, 3, 533, 3, 533, 5, 533, 8316, 10, 533, 3, 534, 3, 534, 5, 534, 8320, 10, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 5, 534, 8328, 10, 534, 5, 534, 8330, 10, 534, 3, 535, 3, 535, 3, 535, 7, 535, 8335, 10, 535, 12, 535, 14, 535, 8338, 11, 535, 3, 536, 3, 536, 5, 536, 8342, 10, 536, 3, 536, 5, 536, 8345, 10, 536, 3, 537, 3, 537, 3, 537, 3, 537, 3, 537, 3, 537, 3, 537, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 5, 538, 8360, 10, 538, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 5, 539, 8372, 10, 539, 3, 540, 3, 540, 3, 540, 3, 541, 3, 541, 3, 541, 7, 541, 8380, 10, 541, 12, 541, 14, 541, 8383, 11, 541, 3, 542, 3, 542, 3, 542, 3, 542, 3, 542, 3, 542, 5, 542, 8391, 10, 542, 3, 543, 3, 543, 3, 543, 5, 543, 8396, 10, 543, 3, 544, 3, 544, 3, 544, 5, 544, 8401, 10, 544, 3, 545, 3, 545, 3, 545, 3, 545, 3, 545, 5, 545, 8408, 10, 545, 3, 545, 5, 545, 8411, 10, 545, 3, 546, 3, 546, 5, 546, 8415, 10, 546, 3, 547, 3, 547, 3, 547, 7, 547, 8420, 10, 547, 12, 547, 14, 547, 8423, 11, 547, 3, 548, 3, 548, 3, 548, 3, 548, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 5, 549, 8446, 10, 549, 3, 549, 3, 549, 3, 550, 3, 550, 3, 550, 7, 550, 8453, 10, 550, 12, 550, 14, 550, 8456, 11, 550, 3, 551, 3, 551, 3, 551, 5, 551, 8461, 10, 551, 3, 551, 3, 551, 5, 551, 8465, 10, 551, 3, 552, 6, 552, 8468, 10, 552, 13, 552, 14, 552, 8469, 3, 553, 3, 553, 3, 553, 3, 553, 3, 553, 3, 553, 3, 553, 3, 553, 5, 553, 8480, 10, 553, 3, 554, 3, 554, 3, 554, 7, 554, 8485, 10, 554, 12, 554, 14, 554, 8488, 11, 554, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 5, 555, 8496, 10, 555, 3, 556, 5, 556, 8499, 10, 556, 3, 556, 3, 556, 3, 556, 3, 556, 3, 556, 3, 556, 3, 556, 5, 556, 8508, 10, 556, 5, 556, 8510, 10, 556, 3, 556, 3, 556, 3, 556, 3, 556, 5, 556, 8516, 10, 556, 3, 557, 3, 557, 5, 557, 8520, 10, 557, 3, 557, 7, 557, 8523, 10, 557, 12, 557, 14, 557, 8526, 11, 557, 3, 558, 3, 558, 3, 558, 3, 558, 3, 558, 3, 558, 3, 558, 3, 558, 3, 558, 3, 558, 3, 558, 5, 558, 8539, 10, 558, 5, 558, 8541, 10, 558, 3, 559, 3, 559, 3, 559, 3, 559, 5, 559, 8547, 10, 559, 3, 560, 3, 560, 5, 560, 8551, 10, 560, 3, 560, 3, 560, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 5, 561, 8560, 10, 561, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 5, 562, 8578, 10, 562, 3, 563, 3, 563, 3, 563, 3, 563, 3, 563, 5, 563, 8585, 10, 563, 3, 564, 3, 564, 5, 564, 8589, 10, 564, 3, 565, 3, 565, 5, 565, 8593, 10, 565, 3, 566, 3, 566, 3, 566, 3, 566, 3, 566, 3, 566, 3, 567, 3, 567, 3, 567, 3, 568, 3, 568, 3, 568, 3, 568, 3, 568, 5, 568, 8609, 10, 568, 3, 569, 3, 569, 3, 569, 3, 569, 3, 569, 5, 569, 8616, 10, 569, 3, 570, 3, 570, 3, 570, 3, 570, 3, 570, 3, 570, 5, 570, 8624, 10, 570, 3, 571, 3, 571, 5, 571, 8628, 10, 571, 3, 572, 3, 572, 3, 572, 3, 572, 3, 572, 5, 572, 8635, 10, 572, 3, 572, 3, 572, 3, 573, 3, 573, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 5, 574, 8648, 10, 574, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 5, 575, 8664, 10, 575, 3, 575, 3, 575, 3, 575, 3, 575, 5, 575, 8670, 10, 575, 3, 575, 3, 575, 3, 575, 3, 575, 5, 575, 8676, 10, 575, 3, 576, 3, 576, 3, 576, 3, 576, 3, 576, 5, 576, 8683, 10, 576, 3, 577, 3, 577, 3, 577, 5, 577, 8688, 10, 577, 3, 578, 3, 578, 3, 579, 3, 579, 5, 579, 8694, 10, 579, 3, 580, 3, 580, 3, 580, 7, 580, 8699, 10, 580, 12, 580, 14, 580, 8702, 11, 580, 3, 581, 3, 581, 3, 581, 7, 581, 8707, 10, 581, 12, 581, 14, 581, 8710, 11, 581, 3, 582, 3, 582, 3, 582, 7, 582, 8715, 10, 582, 12, 582, 14, 582, 8718, 11, 582, 3, 583, 3, 583, 5, 583, 8722, 10, 583, 3, 583, 3, 583, 5, 583, 8726, 10, 583, 3, 584, 5, 584, 8729, 10, 584, 3, 584, 3, 584, 3, 585, 3, 585, 5, 585, 8735, 10, 585, 3, 586, 3, 586, 3, 586, 5, 586, 8740, 10, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 5, 586, 8756, 10, 586, 3, 586, 5, 586, 8759, 10, 586, 5, 586, 8761, 10, 586, 3, 587, 3, 587, 3, 587, 3, 587, 3, 587, 3, 587, 3, 587, 3, 587, 3, 587, 3, 587, 5, 587, 8773, 10, 587, 5, 587, 8775, 10, 587, 3, 588, 3, 588, 5, 588, 8779, 10, 588, 3, 588, 3, 588, 3, 588, 3, 588, 3, 588, 3, 588, 5, 588, 8787, 10, 588, 5, 588, 8789, 10, 588, 3, 588, 3, 588, 3, 588, 5, 588, 8794, 10, 588, 3, 589, 3, 589, 3, 589, 3, 589, 7, 589, 8800, 10, 589, 12, 589, 14, 589, 8803, 11, 589, 3, 590, 5, 590, 8806, 10, 590, 3, 590, 3, 590, 3, 591, 3, 591, 3, 591, 7, 591, 8813, 10, 591, 12, 591, 14, 591, 8816, 11, 591, 3, 592, 3, 592, 3, 592, 7, 592, 8821, 10, 592, 12, 592, 14, 592, 8824, 11, 592, 3, 593, 3, 593, 3, 593, 5, 593, 8829, 10, 593, 3, 594, 5, 594, 8832, 10, 594, 3, 594, 3, 594, 3, 595, 3, 595, 3, 595, 3, 595, 3, 595, 5, 595, 8841, 10, 595, 3, 596, 3, 596, 3, 596, 5, 596, 8846, 10, 596, 3, 597, 3, 597, 3, 597, 7, 597, 8851, 10, 597, 12, 597, 14, 597, 8854, 11, 597, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 5, 598, 8863, 10, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 5, 598, 8889, 10, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 5, 598, 8900, 10, 598, 7, 598, 8902, 10, 598, 12, 598, 14, 598, 8905, 11, 598, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 5, 599, 8912, 10, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 5, 599, 8935, 10, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 3, 599, 5, 599, 8943, 10, 599, 3, 600, 3, 600, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 5, 601, 8953, 10, 601, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 5, 601, 8967, 10, 601, 3, 601, 3, 601, 3, 602, 3, 602, 3, 602, 3, 602, 3, 602, 3, 602, 5, 602, 8977, 10, 602, 3, 603, 3, 603, 5, 603, 8981, 10, 603, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 8995, 10, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9002, 10, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9009, 10, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9016, 10, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9041, 10, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9070, 10, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9109, 10, 604, 5, 604, 9111, 10, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9139, 10, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9160, 10, 604, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 5, 605, 9167, 10, 605, 3, 606, 3, 606, 3, 606, 3, 606, 3, 606, 3, 606, 3, 606, 3, 606, 3, 606, 3, 606, 3, 606, 5, 606, 9180, 10, 606, 3, 607, 3, 607, 3, 607, 3, 607, 3, 607, 3, 608, 3, 608, 3, 608, 7, 608, 9190, 10, 608, 12, 608, 14, 608, 9193, 11, 608, 3, 609, 3, 609, 3, 609, 5, 609, 9198, 10, 609, 3, 610, 3, 610, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 5, 611, 9207, 10, 611, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 5, 612, 9224, 10, 612, 3, 613, 3, 613, 3, 613, 3, 614, 3, 614, 3, 614, 3, 614, 3, 614, 3, 614, 3, 614, 5, 614, 9236, 10, 614, 3, 615, 3, 615, 3, 615, 3, 615, 3, 615, 3, 615, 3, 615, 5, 615, 9245, 10, 615, 3, 616, 3, 616, 3, 616, 5, 616, 9250, 10, 616, 3, 617, 3, 617, 3, 617, 7, 617, 9255, 10, 617, 12, 617, 14, 617, 9258, 11, 617, 3, 618, 3, 618, 3, 618, 3, 618, 3, 619, 3, 619, 3, 619, 5, 619, 9267, 10, 619, 3, 619, 5, 619, 9270, 10, 619, 3, 620, 3, 620, 3, 620, 3, 620, 3, 620, 3, 620, 3, 620, 3, 621, 3, 621, 5, 621, 9281, 10, 621, 3, 622, 3, 622, 3, 622, 3, 622, 5, 622, 9287, 10, 622, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 5, 623, 9302, 10, 623, 3, 624, 3, 624, 3, 624, 3, 624, 3, 624, 3, 624, 5, 624, 9310, 10, 624, 3, 625, 3, 625, 3, 625, 3, 625, 3, 625, 3, 625, 3, 625, 5, 625, 9319, 10, 625, 3, 626, 3, 626, 3, 626, 3, 626, 3, 626, 3, 626, 3, 626, 5, 626, 9328, 10, 626, 3, 626, 5, 626, 9331, 10, 626, 3, 627, 3, 627, 3, 627, 5, 627, 9336, 10, 627, 3, 627, 3, 627, 3, 627, 3, 627, 3, 627, 3, 627, 3, 627, 5, 627, 9345, 10, 627, 3, 628, 3, 628, 3, 628, 5, 628, 9350, 10, 628, 3, 628, 3, 628, 3, 629, 3, 629, 3, 629, 3, 629, 3, 629, 3, 629, 3, 630, 3, 630, 3, 631, 3, 631, 5, 631, 9364, 10, 631, 3, 632, 3, 632, 3, 633, 3, 633, 3, 633, 3, 633, 3, 633, 3, 633, 5, 633, 9374, 10, 633, 3, 634, 3, 634, 3, 634, 3, 634, 3, 634, 3, 634, 5, 634, 9382, 10, 634, 3, 635, 3, 635, 3, 635, 3, 635, 3, 635, 3, 635, 3, 635, 3, 635, 3, 635, 3, 635, 3, 635, 3, 635, 5, 635, 9396, 10, 635, 3, 636, 3, 636, 3, 636, 7, 636, 9401, 10, 636, 12, 636, 14, 636, 9404, 11, 636, 3, 637, 3, 637, 3, 637, 7, 637, 9409, 10, 637, 12, 637, 14, 637, 9412, 11, 637, 3, 638, 3, 638, 3, 638, 3, 638, 3, 638, 5, 638, 9419, 10, 638, 3, 639, 3, 639, 3, 639, 7, 639, 9424, 10, 639, 12, 639, 14, 639, 9427, 11, 639, 3, 640, 3, 640, 3, 640, 5, 640, 9432, 10, 640, 3, 640, 3, 640, 3, 641, 3, 641, 3, 641, 7, 641, 9439, 10, 641, 12, 641, 14, 641, 9442, 11, 641, 3, 642, 3, 642, 3, 642, 3, 642, 3, 642, 5, 642, 9449, 10, 642, 3, 643, 3, 643, 3, 643, 3, 643, 3, 643, 3, 643, 3, 643, 3, 643, 5, 643, 9459, 10, 643, 3, 644, 3, 644, 3, 645, 3, 645, 3, 645, 3, 645, 3, 645, 3, 645, 3, 645, 5, 645, 9470, 10, 645, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 5, 646, 9477, 10, 646, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 5, 647, 9507, 10, 647, 3, 648, 3, 648, 3, 648, 3, 648, 3, 648, 3, 648, 3, 648, 5, 648, 9516, 10, 648, 3, 649, 3, 649, 3, 649, 3, 649, 3, 649, 5, 649, 9523, 10, 649, 3, 650, 3, 650, 3, 650, 3, 650, 3, 650, 3, 650, 3, 651, 6, 651, 9532, 10, 651, 13, 651, 14, 651, 9533, 3, 652, 3, 652, 3, 652, 3, 652, 3, 652, 3, 653, 3, 653, 3, 653, 5, 653, 9544, 10, 653, 3, 654, 3, 654, 5, 654, 9548, 10, 654, 3, 655, 3, 655, 5, 655, 9552, 10, 655, 3, 656, 3, 656, 3, 656, 5, 656, 9557, 10, 656, 3, 656, 3, 656, 3, 656, 3, 656, 3, 656, 3, 656, 5, 656, 9565, 10, 656, 3, 656, 3, 656, 5, 656, 9569, 10, 656, 3, 657, 3, 657, 5, 657, 9573, 10, 657, 3, 658, 6, 658, 9576, 10, 658, 13, 658, 14, 658, 9577, 3, 659, 7, 659, 9581, 10, 659, 12, 659, 14, 659, 9584, 11, 659, 3, 660, 3, 660, 5, 660, 9588, 10, 660, 3, 661, 3, 661, 3, 661, 7, 661, 9593, 10, 661, 12, 661, 14, 661, 9596, 11, 661, 3, 662, 3, 662, 3, 662, 3, 662, 3, 662, 5, 662, 9603, 10, 662, 3, 662, 5, 662, 9606, 10, 662, 3, 663, 3, 663, 3, 663, 7, 663, 9611, 10, 663, 12, 663, 14, 663, 9614, 11, 663, 3, 664, 3, 664, 5, 664, 9618, 10, 664, 3, 665, 3, 665, 3, 665, 7, 665, 9623, 10, 665, 12, 665, 14, 665, 9626, 11, 665, 3, 666, 3, 666, 3, 667, 3, 667, 3, 668, 3, 668, 3, 669, 3, 669, 3, 669, 3, 669, 5, 669, 9638, 10, 669, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 5, 670, 9653, 10, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 3, 670, 5, 670, 9667, 10, 670, 3, 670, 3, 670, 3, 670, 5, 670, 9672, 10, 670, 3, 671, 3, 671, 3, 672, 3, 672, 3, 673, 3, 673, 3, 674, 3, 674, 3, 675, 3, 675, 3, 675, 3, 676, 3, 676, 3, 676, 3, 676, 7, 676, 9689, 10, 676, 12, 676, 14, 676, 9692, 11, 676, 3, 676, 3, 676, 5, 676, 9696, 10, 676, 3, 677, 3, 677, 3, 677, 5, 677, 9701, 10, 677, 3, 678, 3, 678, 3, 678, 3, 678, 3, 678, 5, 678, 9708, 10, 678, 3, 679, 3, 679, 3, 680, 3, 680, 3, 680, 5, 680, 9715, 10, 680, 3, 681, 3, 681, 3, 681, 7, 681, 9720, 10, 681, 12, 681, 14, 681, 9723, 11, 681, 3, 682, 3, 682, 3, 682, 3, 682, 5, 682, 9729, 10, 682, 3, 683, 3, 683, 3, 683, 3, 683, 5, 683, 9735, 10, 683, 3, 684, 3, 684, 3, 684, 3, 684, 5, 684, 9741, 10, 684, 3, 685, 3, 685, 3, 685, 3, 685, 3, 685, 3, 685, 5, 685, 9749, 10, 685, 3, 686, 3, 686, 3, 686, 3, 686, 3, 686, 3, 686, 3, 686, 5, 686, 9758, 10, 686, 3, 687, 3, 687, 3, 688, 3, 688, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 3, 689, 5, 689, 9815, 10, 689, 3, 690, 3, 690, 3, 691, 3, 691, 3, 692, 3, 692, 3, 692, 3, 692, 3, 693, 7, 693, 9826, 10, 693, 12, 693, 14, 693, 9829, 11, 693, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 3, 694, 5, 694, 9851, 10, 694, 3, 695, 3, 695, 3, 696, 3, 696, 3, 696, 3, 696, 5, 696, 9859, 10, 696, 3, 697, 3, 697, 5, 697, 9863, 10, 697, 3, 698, 3, 698, 3, 698, 3, 698, 3, 698, 3, 698, 3, 698, 3, 699, 3, 699, 3, 699, 5, 699, 9875, 10, 699, 5, 699, 9877, 10, 699, 3, 700, 3, 700, 3, 701, 6, 701, 9882, 10, 701, 13, 701, 14, 701, 9883, 3, 702, 3, 702, 3, 702, 3, 702, 3, 703, 3, 703, 3, 703, 5, 703, 9893, 10, 703, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 3, 704, 5, 704, 9911, 10, 704, 3, 704, 3, 704, 3, 705, 3, 705, 3, 705, 3, 705, 5, 705, 9919, 10, 705, 3, 706, 3, 706, 3, 707, 3, 707, 3, 707, 3, 707, 3, 707, 5, 707, 9928, 10, 707, 3, 708, 3, 708, 3, 708, 7, 708, 9933, 10, 708, 12, 708, 14, 708, 9936, 11, 708, 3, 709, 3, 709, 3, 709, 3, 710, 3, 710, 3, 711, 3, 711, 5, 711, 9945, 10, 711, 3, 712, 3, 712, 3, 713, 3, 713, 5, 713, 9951, 10, 713, 3, 714, 3, 714, 3, 715, 3, 715, 3, 715, 5, 715, 9958, 10, 715, 3, 716, 3, 716, 3, 716, 5, 716, 9963, 10, 716, 3, 717, 3, 717, 3, 717, 3, 717, 5, 717, 9969, 10, 717, 3, 718, 3, 718, 5, 718, 9973, 10, 718, 3, 719, 3, 719, 3, 720, 7, 720, 9978, 10, 720, 12, 720, 14, 720, 9981, 11, 720, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 3, 721, 5, 721, 10010, 10, 721, 3, 722, 3, 722, 3, 722, 3, 722, 3, 723, 3, 723, 3, 723, 3, 723, 3, 723, 3, 723, 3, 723, 3, 723, 3, 723, 3, 723, 3, 723, 3, 723, 3, 723, 3, 723, 5, 723, 10030, 10, 723, 3, 724, 3, 724, 5, 724, 10034, 10, 724, 3, 725, 3, 725, 3, 725, 3, 725, 3, 725, 3, 726, 3, 726, 3, 726, 3, 726, 3, 726, 3, 726, 3, 727, 3, 727, 3, 727, 5, 727, 10050, 10, 727, 3, 728, 3, 728, 3, 728, 7, 728, 10055, 10, 728, 12, 728, 14, 728, 10058, 11, 728, 3, 729, 3, 729, 3, 729, 3, 729, 3, 730, 3, 730, 3, 731, 3, 731, 3, 732, 3, 732, 5, 732, 10070, 10, 732, 3, 732, 3, 732, 3, 732, 3, 732, 7, 732, 10076, 10, 732, 12, 732, 14, 732, 10079, 11, 732, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 734, 3, 734, 3, 734, 3, 734, 3, 734, 7, 734, 10096, 10, 734, 12, 734, 14, 734, 10099, 11, 734, 3, 735, 3, 735, 3, 735, 5, 735, 10104, 10, 735, 3, 736, 3, 736, 3, 736, 3, 736, 3, 736, 3, 736, 3, 736, 3, 736, 3, 737, 3, 737, 5, 737, 10116, 10, 737, 3, 738, 6, 738, 10119, 10, 738, 13, 738, 14, 738, 10120, 3, 739, 3, 739, 3, 739, 3, 739, 3, 739, 3, 740, 3, 740, 3, 740, 5, 740, 10131, 10, 740, 3, 741, 3, 741, 3, 741, 3, 742, 3, 742, 3, 742, 3, 742, 3, 742, 3, 743, 3, 743, 3, 743, 3, 743, 3, 743, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 3, 744, 5, 744, 10163, 10, 744, 3, 745, 3, 745, 3, 745, 5, 745, 10168, 10, 745, 3, 746, 3, 746, 3, 746, 3, 746, 3, 746, 7, 746, 10175, 10, 746, 12, 746, 14, 746, 10178, 11, 746, 3, 746, 3, 746, 5, 746, 10182, 10, 746, 3, 747, 3, 747, 5, 747, 10186, 10, 747, 3, 748, 3, 748, 3, 748, 5, 748, 10191, 10, 748, 3, 749, 3, 749, 3, 750, 3, 750, 3, 750, 3, 750, 3, 750, 3, 750, 3, 750, 3, 750, 3, 750, 3, 751, 3, 751, 3, 751, 5, 751, 10207, 10, 751, 3, 752, 3, 752, 3, 752, 3, 752, 3, 752, 3, 753, 3, 753, 3, 754, 3, 754, 3, 754, 3, 754, 3, 754, 3, 754, 3, 754, 3, 754, 3, 754, 5, 754, 10225, 10, 754, 3, 754, 5, 754, 10228, 10, 754, 3, 754, 3, 754, 3, 755, 3, 755, 5, 755, 10234, 10, 755, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 3, 756, 5, 756, 10262, 10, 756, 3, 757, 3, 757, 3, 757, 3, 757, 3, 757, 3, 757, 3, 757, 3, 757, 5, 757, 10272, 10, 757, 3, 758, 3, 758, 3, 758, 6, 758, 10277, 10, 758, 13, 758, 14, 758, 10278, 5, 758, 10281, 10, 758, 3, 759, 3, 759, 3, 759, 5, 759, 10286, 10, 759, 3, 760, 3, 760, 3, 760, 3, 760, 3, 761, 3, 761, 3, 761, 7, 761, 10295, 10, 761, 12, 761, 14, 761, 10298, 11, 761, 3, 762, 3, 762, 3, 762, 3, 762, 3, 762, 3, 763, 3, 763, 3, 763, 5, 763, 10308, 10, 763, 3, 764, 3, 764, 3, 764, 3, 764, 3, 764, 3, 764, 3, 764, 3, 765, 3, 765, 3, 765, 3, 766, 3, 766, 3, 766, 3, 766, 3, 766, 3, 766, 3, 766, 3, 766, 3, 766, 5, 766, 10329, 10, 766, 3, 766, 3, 766, 3, 767, 3, 767, 3, 767, 5, 767, 10336, 10, 767, 3, 768, 3, 768, 3, 768, 7, 768, 10341, 10, 768, 12, 768, 14, 768, 10344, 11, 768, 3, 769, 3, 769, 3, 769, 5, 769, 10349, 10, 769, 3, 769, 5, 769, 10352, 10, 769, 3, 770, 3, 770, 3, 770, 3, 770, 3, 770, 3, 770, 3, 770, 3, 770, 3, 770, 5, 770, 10363, 10, 770, 3, 770, 3, 770, 3, 770, 3, 770, 3, 770, 5, 770, 10370, 10, 770, 5, 770, 10372, 10, 770, 3, 770, 3, 770, 3, 771, 3, 771, 3, 771, 3, 771, 3, 771, 5, 771, 10381, 10, 771, 3, 772, 3, 772, 3, 772, 7, 772, 10386, 10, 772, 12, 772, 14, 772, 10389, 11, 772, 3, 773, 3, 773, 3, 773, 5, 773, 10394, 10, 773, 3, 774, 3, 774, 3, 774, 3, 774, 5, 774, 10400, 10, 774, 3, 775, 3, 775, 5, 775, 10404, 10, 775, 3, 776, 3, 776, 3, 776, 3, 776, 3, 776, 3, 776, 3, 776, 3, 776, 3, 777, 3, 777, 3, 778, 3, 778, 3, 778, 5, 778, 10419, 10, 778, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 3, 779, 5, 779, 10436, 10, 779, 5, 779, 10438, 10, 779, 3, 780, 3, 780, 3, 780, 3, 780, 3, 780, 3, 781, 3, 781, 3, 781, 3, 781, 3, 782, 3, 782, 3, 782, 3, 783, 3, 783, 3, 783, 3, 783, 3, 784, 3, 784, 3, 784, 3, 784, 3, 785, 3, 785, 5, 785, 10462, 10, 785, 3, 785, 3, 785, 5, 785, 10466, 10, 785, 3, 786, 3, 786, 3, 786, 3, 786, 3, 786, 3, 786, 3, 786, 3, 786, 3, 786, 5, 786, 10477, 10, 786, 3, 786, 5, 786, 10480, 10, 786, 3, 787, 3, 787, 5, 787, 10484, 10, 787, 3, 788, 3, 788, 3, 788, 5, 788, 10489, 10, 788, 3, 789, 6, 789, 10492, 10, 789, 13, 789, 14, 789, 10493, 3, 790, 3, 790, 3, 790, 3, 790, 3, 790, 3, 791, 3, 791, 3, 791, 7, 791, 10504, 10, 791, 12, 791, 14, 791, 10507, 11, 791, 3, 792, 3, 792, 3, 792, 5, 792, 10512, 10, 792, 3, 793, 3, 793, 5, 793, 10516, 10, 793, 3, 794, 3, 794, 5, 794, 10520, 10, 794, 3, 795, 3, 795, 5, 795, 10524, 10, 795, 3, 796, 3, 796, 3, 796, 5, 796, 10529, 10, 796, 3, 797, 3, 797, 5, 797, 10533, 10, 797, 3, 798, 3, 798, 3, 799, 3, 799, 3, 799, 3, 799, 3, 799, 3, 799, 3, 799, 3, 799, 3, 800, 3, 800, 3, 801, 3, 801, 3, 802, 3, 802, 3, 803, 3, 803, 3, 804, 3, 804, 3, 804, 3, 805, 3, 805, 3, 805, 3, 805, 3, 805, 5, 805, 10561, 10, 805, 3, 805, 2, 3, 1194, 806, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, 810, 812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 838, 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, 870, 872, 874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 928, 930, 932, 934, 936, 938, 940, 942, 944, 946, 948, 950, 952, 954, 956, 958, 960, 962, 964, 966, 968, 970, 972, 974, 976, 978, 980, 982, 984, 986, 988, 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, 1016, 1018, 1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 1038, 1040, 1042, 1044, 1046, 1048, 1050, 1052, 1054, 1056, 1058, 1060, 1062, 1064, 1066, 1068, 1070, 1072, 1074, 1076, 1078, 1080, 1082, 1084, 1086, 1088, 1090, 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1106, 1108, 1110, 1112, 1114, 1116, 1118, 1120, 1122, 1124, 1126, 1128, 1130, 1132, 1134, 1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, 1152, 1154, 1156, 1158, 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, 1198, 1200, 1202, 1204, 1206, 1208, 1210, 1212, 1214, 1216, 1218, 1220, 1222, 1224, 1226, 1228, 1230, 1232, 1234, 1236, 1238, 1240, 1242, 1244, 1246, 1248, 1250, 1252, 1254, 1256, 1258, 1260, 1262, 1264, 1266, 1268, 1270, 1272, 1274, 1276, 1278, 1280, 1282, 1284, 1286, 1288, 1290, 1292, 1294, 1296, 1298, 1300, 1302, 1304, 1306, 1308, 1310, 1312, 1314, 1316, 1318, 1320, 1322, 1324, 1326, 1328, 1330, 1332, 1334, 1336, 1338, 1340, 1342, 1344, 1346, 1348, 1350, 1352, 1354, 1356, 1358, 1360, 1362, 1364, 1366, 1368, 1370, 1372, 1374, 1376, 1378, 1380, 1382, 1384, 1386, 1388, 1390, 1392, 1394, 1396, 1398, 1400, 1402, 1404, 1406, 1408, 1410, 1412, 1414, 1416, 1418, 1420, 1422, 1424, 1426, 1428, 1430, 1432, 1434, 1436, 1438, 1440, 1442, 1444, 1446, 1448, 1450, 1452, 1454, 1456, 1458, 1460, 1462, 1464, 1466, 1468, 1470, 1472, 1474, 1476, 1478, 1480, 1482, 1484, 1486, 1488, 1490, 1492, 1494, 1496, 1498, 1500, 1502, 1504, 1506, 1508, 1510, 1512, 1514, 1516, 1518, 1520, 1522, 1524, 1526, 1528, 1530, 1532, 1534, 1536, 1538, 1540, 1542, 1544, 1546, 1548, 1550, 1552, 1554, 1556, 1558, 1560, 1562, 1564, 1566, 1568, 1570, 1572, 1574, 1576, 1578, 1580, 1582, 1584, 1586, 1588, 1590, 1592, 1594, 1596, 1598, 1600, 1602, 1604, 1606, 1608, 2, 67, 4, 2, 197, 197, 357, 357, 4, 2, 68, 68, 311, 311, 4, 2, 101, 101, 311, 311, 5, 2, 68, 68, 101, 101, 311, 311, 4, 2, 135, 135, 193, 193, 4, 2, 247, 247, 325, 325, 4, 2, 12, 12, 96, 96, 4, 2, 164, 164, 356, 356, 4, 2, 182, 182, 223, 223, 7, 2, 32, 32, 281, 281, 322, 322, 345, 345, 347, 347, 4, 2, 66, 66, 96, 96, 4, 2, 345, 345, 347, 347, 4, 2, 202, 202, 226, 226, 11, 2, 32, 32, 162, 162, 167, 167, 181, 181, 221, 221, 229, 229, 335, 335, 338, 338, 431, 431, 5, 2, 115, 115, 277, 277, 329, 329, 4, 2, 55, 55, 80, 80, 5, 2, 175, 175, 253, 253, 255, 255, 7, 2, 32, 32, 90, 90, 184, 184, 234, 234, 362, 362, 4, 2, 94, 94, 228, 228, 3, 2, 441, 442, 4, 2, 94, 94, 407, 407, 4, 2, 334, 334, 407, 407, 4, 2, 213, 213, 289, 289, 5, 2, 314, 314, 350, 350, 438, 438, 4, 2, 66, 66, 70, 70, 7, 2, 214, 214, 322, 322, 343, 343, 354, 354, 448, 449, 4, 2, 12, 12, 55, 55, 5, 2, 213, 213, 289, 289, 435, 435, 5, 2, 177, 177, 316, 316, 342, 342, 6, 2, 90, 90, 184, 184, 234, 234, 362, 362, 4, 2, 153, 153, 247, 247, 4, 2, 306, 306, 326, 326, 3, 2, 33, 34, 4, 2, 101, 101, 342, 342, 4, 2, 203, 203, 327, 327, 4, 2, 215, 215, 247, 247, 4, 2, 313, 313, 407, 407, 4, 2, 209, 209, 261, 261, 6, 2, 115, 115, 117, 117, 121, 121, 128, 128, 4, 2, 353, 353, 470, 470, 4, 2, 384, 385, 399, 399, 3, 2, 384, 385, 3, 2, 411, 412, 3, 2, 20, 21, 4, 2, 119, 119, 124, 124, 7, 2, 12, 12, 18, 19, 23, 23, 25, 25, 27, 27, 3, 2, 14, 15, 5, 2, 11, 11, 16, 16, 29, 29, 4, 2, 32, 32, 58, 58, 5, 2, 41, 41, 75, 75, 97, 97, 4, 2, 168, 168, 190, 190, 4, 2, 297, 297, 443, 443, 4, 2, 210, 210, 282, 282, 5, 2, 32, 32, 36, 36, 92, 92, 8, 2, 11, 12, 14, 19, 23, 23, 25, 25, 27, 27, 29, 29, 4, 2, 22, 22, 24, 24, 3, 2, 476, 479, 10, 2, 126, 126, 131, 379, 426, 445, 448, 462, 464, 464, 466, 466, 468, 468, 471, 481, 5, 2, 108, 125, 127, 130, 465, 465, 6, 2, 32, 54, 56, 72, 74, 107, 447, 447, 4, 2, 64, 64, 118, 118, 4, 2, 12, 12, 22, 22, 4, 2, 169, 169, 500, 500, 4, 2, 146, 146, 212, 212, 38, 2, 35, 35, 37, 37, 45, 47, 55, 55, 59, 59, 63, 63, 94, 94, 118, 118, 125, 125, 132, 132, 146, 146, 155, 155, 159, 159, 163, 163, 169, 169, 174, 174, 209, 209, 212, 212, 234, 234, 242, 242, 258, 258, 261, 262, 272, 272, 286, 286, 300, 300, 306, 306, 312, 312, 316, 317, 326, 326, 353, 353, 426, 427, 470, 470, 483, 495, 497, 497, 499, 511, 513, 513, 2, 11399, 2, 1610, 3, 2, 2, 2, 4, 1613, 3, 2, 2, 2, 6, 1615, 3, 2, 2, 2, 8, 1623, 3, 2, 2, 2, 10, 1750, 3, 2, 2, 2, 12, 1752, 3, 2, 2, 2, 14, 1756, 3, 2, 2, 2, 16, 1759, 3, 2, 2, 2, 18, 1767, 3, 2, 2, 2, 20, 1772, 3, 2, 2, 2, 22, 1778, 3, 2, 2, 2, 24, 1799, 3, 2, 2, 2, 26, 1811, 3, 2, 2, 2, 28, 1813, 3, 2, 2, 2, 30, 1819, 3, 2, 2, 2, 32, 1829, 3, 2, 2, 2, 34, 1831, 3, 2, 2, 2, 36, 1840, 3, 2, 2, 2, 38, 1848, 3, 2, 2, 2, 40, 1854, 3, 2, 2, 2, 42, 1861, 3, 2, 2, 2, 44, 1863, 3, 2, 2, 2, 46, 1881, 3, 2, 2, 2, 48, 1886, 3, 2, 2, 2, 50, 1895, 3, 2, 2, 2, 52, 1897, 3, 2, 2, 2, 54, 1911, 3, 2, 2, 2, 56, 1913, 3, 2, 2, 2, 58, 1942, 3, 2, 2, 2, 60, 1944, 3, 2, 2, 2, 62, 1952, 3, 2, 2, 2, 64, 1962, 3, 2, 2, 2, 66, 1969, 3, 2, 2, 2, 68, 1975, 3, 2, 2, 2, 70, 1992, 3, 2, 2, 2, 72, 1997, 3, 2, 2, 2, 74, 2001, 3, 2, 2, 2, 76, 2003, 3, 2, 2, 2, 78, 2014, 3, 2, 2, 2, 80, 2018, 3, 2, 2, 2, 82, 2023, 3, 2, 2, 2, 84, 2028, 3, 2, 2, 2, 86, 2030, 3, 2, 2, 2, 88, 2042, 3, 2, 2, 2, 90, 2049, 3, 2, 2, 2, 92, 2051, 3, 2, 2, 2, 94, 2053, 3, 2, 2, 2, 96, 2055, 3, 2, 2, 2, 98, 2167, 3, 2, 2, 2, 100, 2169, 3, 2, 2, 2, 102, 2185, 3, 2, 2, 2, 104, 2187, 3, 2, 2, 2, 106, 2443, 3, 2, 2, 2, 108, 2450, 3, 2, 2, 2, 110, 2455, 3, 2, 2, 2, 112, 2460, 3, 2, 2, 2, 114, 2465, 3, 2, 2, 2, 116, 2473, 3, 2, 2, 2, 118, 2475, 3, 2, 2, 2, 120, 2482, 3, 2, 2, 2, 122, 2484, 3, 2, 2, 2, 124, 2492, 3, 2, 2, 2, 126, 2504, 3, 2, 2, 2, 128, 2520, 3, 2, 2, 2, 130, 2548, 3, 2, 2, 2, 132, 2550, 3, 2, 2, 2, 134, 2553, 3, 2, 2, 2, 136, 2561, 3, 2, 2, 2, 138, 2566, 3, 2, 2, 2, 140, 2597, 3, 2, 2, 2, 142, 2599, 3, 2, 2, 2, 144, 2626, 3, 2, 2, 2, 146, 2628, 3, 2, 2, 2, 148, 2632, 3, 2, 2, 2, 150, 2637, 3, 2, 2, 2, 152, 2644, 3, 2, 2, 2, 154, 2649, 3, 2, 2, 2, 156, 2687, 3, 2, 2, 2, 158, 2691, 3, 2, 2, 2, 160, 2698, 3, 2, 2, 2, 162, 2702, 3, 2, 2, 2, 164, 2704, 3, 2, 2, 2, 166, 2712, 3, 2, 2, 2, 168, 2723, 3, 2, 2, 2, 170, 2725, 3, 2, 2, 2, 172, 2733, 3, 2, 2, 2, 174, 2735, 3, 2, 2, 2, 176, 2784, 3, 2, 2, 2, 178, 2788, 3, 2, 2, 2, 180, 2795, 3, 2, 2, 2, 182, 2797, 3, 2, 2, 2, 184, 2805, 3, 2, 2, 2, 186, 2816, 3, 2, 2, 2, 188, 2820, 3, 2, 2, 2, 190, 2822, 3, 2, 2, 2, 192, 2827, 3, 2, 2, 2, 194, 2837, 3, 2, 2, 2, 196, 2848, 3, 2, 2, 2, 198, 2888, 3, 2, 2, 2, 200, 2893, 3, 2, 2, 2, 202, 2900, 3, 2, 2, 2, 204, 2902, 3, 2, 2, 2, 206, 2910, 3, 2, 2, 2, 208, 2913, 3, 2, 2, 2, 210, 2920, 3, 2, 2, 2, 212, 2980, 3, 2, 2, 2, 214, 2985, 3, 2, 2, 2, 216, 2992, 3, 2, 2, 2, 218, 2994, 3, 2, 2, 2, 220, 3002, 3, 2, 2, 2, 222, 3010, 3, 2, 2, 2, 224, 3015, 3, 2, 2, 2, 226, 3017, 3, 2, 2, 2, 228, 3025, 3, 2, 2, 2, 230, 3041, 3, 2, 2, 2, 232, 3052, 3, 2, 2, 2, 234, 3054, 3, 2, 2, 2, 236, 3058, 3, 2, 2, 2, 238, 3068, 3, 2, 2, 2, 240, 3076, 3, 2, 2, 2, 242, 3080, 3, 2, 2, 2, 244, 3082, 3, 2, 2, 2, 246, 3089, 3, 2, 2, 2, 248, 3111, 3, 2, 2, 2, 250, 3116, 3, 2, 2, 2, 252, 3123, 3, 2, 2, 2, 254, 3135, 3, 2, 2, 2, 256, 3140, 3, 2, 2, 2, 258, 3147, 3, 2, 2, 2, 260, 3149, 3, 2, 2, 2, 262, 3153, 3, 2, 2, 2, 264, 3167, 3, 2, 2, 2, 266, 3178, 3, 2, 2, 2, 268, 3191, 3, 2, 2, 2, 270, 3205, 3, 2, 2, 2, 272, 3207, 3, 2, 2, 2, 274, 3221, 3, 2, 2, 2, 276, 3229, 3, 2, 2, 2, 278, 3231, 3, 2, 2, 2, 280, 3238, 3, 2, 2, 2, 282, 3249, 3, 2, 2, 2, 284, 3260, 3, 2, 2, 2, 286, 3267, 3, 2, 2, 2, 288, 3270, 3, 2, 2, 2, 290, 3304, 3, 2, 2, 2, 292, 3308, 3, 2, 2, 2, 294, 3316, 3, 2, 2, 2, 296, 3318, 3, 2, 2, 2, 298, 3326, 3, 2, 2, 2, 300, 3341, 3, 2, 2, 2, 302, 3343, 3, 2, 2, 2, 304, 3350, 3, 2, 2, 2, 306, 3356, 3, 2, 2, 2, 308, 3360, 3, 2, 2, 2, 310, 3364, 3, 2, 2, 2, 312, 3366, 3, 2, 2, 2, 314, 3377, 3, 2, 2, 2, 316, 3379, 3, 2, 2, 2, 318, 3387, 3, 2, 2, 2, 320, 3401, 3, 2, 2, 2, 322, 3411, 3, 2, 2, 2, 324, 3413, 3, 2, 2, 2, 326, 3422, 3, 2, 2, 2, 328, 3425, 3, 2, 2, 2, 330, 3532, 3, 2, 2, 2, 332, 3534, 3, 2, 2, 2, 334, 3550, 3, 2, 2, 2, 336, 3553, 3, 2, 2, 2, 338, 3559, 3, 2, 2, 2, 340, 3576, 3, 2, 2, 2, 342, 3584, 3, 2, 2, 2, 344, 3586, 3, 2, 2, 2, 346, 3594, 3, 2, 2, 2, 348, 3599, 3, 2, 2, 2, 350, 3614, 3, 2, 2, 2, 352, 3616, 3, 2, 2, 2, 354, 3619, 3, 2, 2, 2, 356, 3621, 3, 2, 2, 2, 358, 3648, 3, 2, 2, 2, 360, 3653, 3, 2, 2, 2, 362, 3655, 3, 2, 2, 2, 364, 3662, 3, 2, 2, 2, 366, 3664, 3, 2, 2, 2, 368, 3730, 3, 2, 2, 2, 370, 3732, 3, 2, 2, 2, 372, 3747, 3, 2, 2, 2, 374, 3755, 3, 2, 2, 2, 376, 3778, 3, 2, 2, 2, 378, 3782, 3, 2, 2, 2, 380, 3802, 3, 2, 2, 2, 382, 3804, 3, 2, 2, 2, 384, 3813, 3, 2, 2, 2, 386, 3824, 3, 2, 2, 2, 388, 3839, 3, 2, 2, 2, 390, 3848, 3, 2, 2, 2, 392, 3853, 3, 2, 2, 2, 394, 3858, 3, 2, 2, 2, 396, 3863, 3, 2, 2, 2, 398, 3868, 3, 2, 2, 2, 400, 3870, 3, 2, 2, 2, 402, 3872, 3, 2, 2, 2, 404, 3881, 3, 2, 2, 2, 406, 3921, 3, 2, 2, 2, 408, 3927, 3, 2, 2, 2, 410, 3929, 3, 2, 2, 2, 412, 3944, 3, 2, 2, 2, 414, 3949, 3, 2, 2, 2, 416, 3952, 3, 2, 2, 2, 418, 3956, 3, 2, 2, 2, 420, 3961, 3, 2, 2, 2, 422, 3963, 3, 2, 2, 2, 424, 3965, 3, 2, 2, 2, 426, 3972, 3, 2, 2, 2, 428, 3976, 3, 2, 2, 2, 430, 3978, 3, 2, 2, 2, 432, 3986, 3, 2, 2, 2, 434, 3988, 3, 2, 2, 2, 436, 3992, 3, 2, 2, 2, 438, 4005, 3, 2, 2, 2, 440, 4010, 3, 2, 2, 2, 442, 4015, 3, 2, 2, 2, 444, 4029, 3, 2, 2, 2, 446, 4057, 3, 2, 2, 2, 448, 4059, 3, 2, 2, 2, 450, 4067, 3, 2, 2, 2, 452, 4073, 3, 2, 2, 2, 454, 4081, 3, 2, 2, 2, 456, 4093, 3, 2, 2, 2, 458, 4095, 3, 2, 2, 2, 460, 4210, 3, 2, 2, 2, 462, 4212, 3, 2, 2, 2, 464, 4216, 3, 2, 2, 2, 466, 4224, 3, 2, 2, 2, 468, 4235, 3, 2, 2, 2, 470, 4237, 3, 2, 2, 2, 472, 4241, 3, 2, 2, 2, 474, 4249, 3, 2, 2, 2, 476, 4255, 3, 2, 2, 2, 478, 4257, 3, 2, 2, 2, 480, 4302, 3, 2, 2, 2, 482, 4308, 3, 2, 2, 2, 484, 4310, 3, 2, 2, 2, 486, 4324, 3, 2, 2, 2, 488, 4357, 3, 2, 2, 2, 490, 4361, 3, 2, 2, 2, 492, 4366, 3, 2, 2, 2, 494, 4375, 3, 2, 2, 2, 496, 4379, 3, 2, 2, 2, 498, 4381, 3, 2, 2, 2, 500, 4406, 3, 2, 2, 2, 502, 4408, 3, 2, 2, 2, 504, 4428, 3, 2, 2, 2, 506, 4448, 3, 2, 2, 2, 508, 4468, 3, 2, 2, 2, 510, 4470, 3, 2, 2, 2, 512, 4476, 3, 2, 2, 2, 514, 4561, 3, 2, 2, 2, 516, 4586, 3, 2, 2, 2, 518, 4593, 3, 2, 2, 2, 520, 4609, 3, 2, 2, 2, 522, 4611, 3, 2, 2, 2, 524, 4613, 3, 2, 2, 2, 526, 4621, 3, 2, 2, 2, 528, 4627, 3, 2, 2, 2, 530, 4631, 3, 2, 2, 2, 532, 4639, 3, 2, 2, 2, 534, 4650, 3, 2, 2, 2, 536, 4799, 3, 2, 2, 2, 538, 4803, 3, 2, 2, 2, 540, 4896, 3, 2, 2, 2, 542, 4901, 3, 2, 2, 2, 544, 4905, 3, 2, 2, 2, 546, 4911, 3, 2, 2, 2, 548, 4979, 3, 2, 2, 2, 550, 4981, 3, 2, 2, 2, 552, 4985, 3, 2, 2, 2, 554, 4987, 3, 2, 2, 2, 556, 5014, 3, 2, 2, 2, 558, 5031, 3, 2, 2, 2, 560, 5033, 3, 2, 2, 2, 562, 5050, 3, 2, 2, 2, 564, 5110, 3, 2, 2, 2, 566, 5112, 3, 2, 2, 2, 568, 5123, 3, 2, 2, 2, 570, 5129, 3, 2, 2, 2, 572, 5131, 3, 2, 2, 2, 574, 5155, 3, 2, 2, 2, 576, 5161, 3, 2, 2, 2, 578, 5167, 3, 2, 2, 2, 580, 5169, 3, 2, 2, 2, 582, 5178, 3, 2, 2, 2, 584, 5190, 3, 2, 2, 2, 586, 5219, 3, 2, 2, 2, 588, 5221, 3, 2, 2, 2, 590, 5258, 3, 2, 2, 2, 592, 5262, 3, 2, 2, 2, 594, 5266, 3, 2, 2, 2, 596, 5270, 3, 2, 2, 2, 598, 5275, 3, 2, 2, 2, 600, 5277, 3, 2, 2, 2, 602, 5296, 3, 2, 2, 2, 604, 5309, 3, 2, 2, 2, 606, 5317, 3, 2, 2, 2, 608, 5319, 3, 2, 2, 2, 610, 5330, 3, 2, 2, 2, 612, 5334, 3, 2, 2, 2, 614, 5339, 3, 2, 2, 2, 616, 5346, 3, 2, 2, 2, 618, 5348, 3, 2, 2, 2, 620, 5369, 3, 2, 2, 2, 622, 5371, 3, 2, 2, 2, 624, 5377, 3, 2, 2, 2, 626, 5385, 3, 2, 2, 2, 628, 5401, 3, 2, 2, 2, 630, 5403, 3, 2, 2, 2, 632, 5409, 3, 2, 2, 2, 634, 5430, 3, 2, 2, 2, 636, 5439, 3, 2, 2, 2, 638, 5441, 3, 2, 2, 2, 640, 5443, 3, 2, 2, 2, 642, 5457, 3, 2, 2, 2, 644, 5459, 3, 2, 2, 2, 646, 5464, 3, 2, 2, 2, 648, 5466, 3, 2, 2, 2, 650, 5481, 3, 2, 2, 2, 652, 5489, 3, 2, 2, 2, 654, 5492, 3, 2, 2, 2, 656, 5501, 3, 2, 2, 2, 658, 5542, 3, 2, 2, 2, 660, 5552, 3, 2, 2, 2, 662, 5559, 3, 2, 2, 2, 664, 5561, 3, 2, 2, 2, 666, 5576, 3, 2, 2, 2, 668, 5578, 3, 2, 2, 2, 670, 5581, 3, 2, 2, 2, 672, 5589, 3, 2, 2, 2, 674, 5596, 3, 2, 2, 2, 676, 5602, 3, 2, 2, 2, 678, 5640, 3, 2, 2, 2, 680, 5654, 3, 2, 2, 2, 682, 5668, 3, 2, 2, 2, 684, 5692, 3, 2, 2, 2, 686, 5699, 3, 2, 2, 2, 688, 5704, 3, 2, 2, 2, 690, 5712, 3, 2, 2, 2, 692, 5715, 3, 2, 2, 2, 694, 5719, 3, 2, 2, 2, 696, 5726, 3, 2, 2, 2, 698, 5762, 3, 2, 2, 2, 700, 5769, 3, 2, 2, 2, 702, 5771, 3, 2, 2, 2, 704, 5784, 3, 2, 2, 2, 706, 5786, 3, 2, 2, 2, 708, 5831, 3, 2, 2, 2, 710, 5833, 3, 2, 2, 2, 712, 5868, 3, 2, 2, 2, 714, 5870, 3, 2, 2, 2, 716, 5872, 3, 2, 2, 2, 718, 5874, 3, 2, 2, 2, 720, 5882, 3, 2, 2, 2, 722, 5896, 3, 2, 2, 2, 724, 6366, 3, 2, 2, 2, 726, 6370, 3, 2, 2, 2, 728, 6375, 3, 2, 2, 2, 730, 6434, 3, 2, 2, 2, 732, 6438, 3, 2, 2, 2, 734, 6657, 3, 2, 2, 2, 736, 6659, 3, 2, 2, 2, 738, 6667, 3, 2, 2, 2, 740, 6683, 3, 2, 2, 2, 742, 6690, 3, 2, 2, 2, 744, 6692, 3, 2, 2, 2, 746, 6883, 3, 2, 2, 2, 748, 6885, 3, 2, 2, 2, 750, 6893, 3, 2, 2, 2, 752, 6901, 3, 2, 2, 2, 754, 6930, 3, 2, 2, 2, 756, 6932, 3, 2, 2, 2, 758, 6941, 3, 2, 2, 2, 760, 6949, 3, 2, 2, 2, 762, 6988, 3, 2, 2, 2, 764, 7002, 3, 2, 2, 2, 766, 7004, 3, 2, 2, 2, 768, 7024, 3, 2, 2, 2, 770, 7026, 3, 2, 2, 2, 772, 7039, 3, 2, 2, 2, 774, 7043, 3, 2, 2, 2, 776, 7045, 3, 2, 2, 2, 778, 7050, 3, 2, 2, 2, 780, 7052, 3, 2, 2, 2, 782, 7059, 3, 2, 2, 2, 784, 7061, 3, 2, 2, 2, 786, 7068, 3, 2, 2, 2, 788, 7120, 3, 2, 2, 2, 790, 7125, 3, 2, 2, 2, 792, 7137, 3, 2, 2, 2, 794, 7139, 3, 2, 2, 2, 796, 7151, 3, 2, 2, 2, 798, 7159, 3, 2, 2, 2, 800, 7161, 3, 2, 2, 2, 802, 7193, 3, 2, 2, 2, 804, 7195, 3, 2, 2, 2, 806, 7198, 3, 2, 2, 2, 808, 7206, 3, 2, 2, 2, 810, 7209, 3, 2, 2, 2, 812, 7213, 3, 2, 2, 2, 814, 7228, 3, 2, 2, 2, 816, 7232, 3, 2, 2, 2, 818, 7234, 3, 2, 2, 2, 820, 7245, 3, 2, 2, 2, 822, 7250, 3, 2, 2, 2, 824, 7264, 3, 2, 2, 2, 826, 7272, 3, 2, 2, 2, 828, 7274, 3, 2, 2, 2, 830, 7280, 3, 2, 2, 2, 832, 7285, 3, 2, 2, 2, 834, 7292, 3, 2, 2, 2, 836, 7320, 3, 2, 2, 2, 838, 7322, 3, 2, 2, 2, 840, 7401, 3, 2, 2, 2, 842, 7403, 3, 2, 2, 2, 844, 7405, 3, 2, 2, 2, 846, 7429, 3, 2, 2, 2, 848, 7434, 3, 2, 2, 2, 850, 7449, 3, 2, 2, 2, 852, 7461, 3, 2, 2, 2, 854, 7463, 3, 2, 2, 2, 856, 7471, 3, 2, 2, 2, 858, 7473, 3, 2, 2, 2, 860, 7478, 3, 2, 2, 2, 862, 7483, 3, 2, 2, 2, 864, 7487, 3, 2, 2, 2, 866, 7491, 3, 2, 2, 2, 868, 7495, 3, 2, 2, 2, 870, 7499, 3, 2, 2, 2, 872, 7506, 3, 2, 2, 2, 874, 7508, 3, 2, 2, 2, 876, 7511, 3, 2, 2, 2, 878, 7521, 3, 2, 2, 2, 880, 7539, 3, 2, 2, 2, 882, 7550, 3, 2, 2, 2, 884, 7552, 3, 2, 2, 2, 886, 7560, 3, 2, 2, 2, 888, 7565, 3, 2, 2, 2, 890, 7570, 3, 2, 2, 2, 892, 7572, 3, 2, 2, 2, 894, 7583, 3, 2, 2, 2, 896, 7589, 3, 2, 2, 2, 898, 7618, 3, 2, 2, 2, 900, 7625, 3, 2, 2, 2, 902, 7637, 3, 2, 2, 2, 904, 7639, 3, 2, 2, 2, 906, 7647, 3, 2, 2, 2, 908, 7671, 3, 2, 2, 2, 910, 7673, 3, 2, 2, 2, 912, 7675, 3, 2, 2, 2, 914, 7683, 3, 2, 2, 2, 916, 7699, 3, 2, 2, 2, 918, 7710, 3, 2, 2, 2, 920, 7715, 3, 2, 2, 2, 922, 7717, 3, 2, 2, 2, 924, 7728, 3, 2, 2, 2, 926, 7730, 3, 2, 2, 2, 928, 7741, 3, 2, 2, 2, 930, 7755, 3, 2, 2, 2, 932, 7759, 3, 2, 2, 2, 934, 7765, 3, 2, 2, 2, 936, 7767, 3, 2, 2, 2, 938, 7776, 3, 2, 2, 2, 940, 7794, 3, 2, 2, 2, 942, 7796, 3, 2, 2, 2, 944, 7799, 3, 2, 2, 2, 946, 7807, 3, 2, 2, 2, 948, 7815, 3, 2, 2, 2, 950, 7824, 3, 2, 2, 2, 952, 7832, 3, 2, 2, 2, 954, 7836, 3, 2, 2, 2, 956, 7846, 3, 2, 2, 2, 958, 7869, 3, 2, 2, 2, 960, 7873, 3, 2, 2, 2, 962, 7901, 3, 2, 2, 2, 964, 7916, 3, 2, 2, 2, 966, 7918, 3, 2, 2, 2, 968, 7921, 3, 2, 2, 2, 970, 7927, 3, 2, 2, 2, 972, 7935, 3, 2, 2, 2, 974, 7947, 3, 2, 2, 2, 976, 7951, 3, 2, 2, 2, 978, 7961, 3, 2, 2, 2, 980, 7965, 3, 2, 2, 2, 982, 7981, 3, 2, 2, 2, 984, 7985, 3, 2, 2, 2, 986, 7990, 3, 2, 2, 2, 988, 7992, 3, 2, 2, 2, 990, 8002, 3, 2, 2, 2, 992, 8006, 3, 2, 2, 2, 994, 8008, 3, 2, 2, 2, 996, 8012, 3, 2, 2, 2, 998, 8020, 3, 2, 2, 2, 1000, 8036, 3, 2, 2, 2, 1002, 8040, 3, 2, 2, 2, 1004, 8065, 3, 2, 2, 2, 1006, 8067, 3, 2, 2, 2, 1008, 8076, 3, 2, 2, 2, 1010, 8078, 3, 2, 2, 2, 1012, 8085, 3, 2, 2, 2, 1014, 8089, 3, 2, 2, 2, 1016, 8091, 3, 2, 2, 2, 1018, 8093, 3, 2, 2, 2, 1020, 8099, 3, 2, 2, 2, 1022, 8101, 3, 2, 2, 2, 1024, 8114, 3, 2, 2, 2, 1026, 8116, 3, 2, 2, 2, 1028, 8119, 3, 2, 2, 2, 1030, 8124, 3, 2, 2, 2, 1032, 8129, 3, 2, 2, 2, 1034, 8138, 3, 2, 2, 2, 1036, 8144, 3, 2, 2, 2, 1038, 8148, 3, 2, 2, 2, 1040, 8151, 3, 2, 2, 2, 1042, 8155, 3, 2, 2, 2, 1044, 8159, 3, 2, 2, 2, 1046, 8174, 3, 2, 2, 2, 1048, 8176, 3, 2, 2, 2, 1050, 8193, 3, 2, 2, 2, 1052, 8195, 3, 2, 2, 2, 1054, 8252, 3, 2, 2, 2, 1056, 8276, 3, 2, 2, 2, 1058, 8287, 3, 2, 2, 2, 1060, 8302, 3, 2, 2, 2, 1062, 8304, 3, 2, 2, 2, 1064, 8315, 3, 2, 2, 2, 1066, 8329, 3, 2, 2, 2, 1068, 8331, 3, 2, 2, 2, 1070, 8339, 3, 2, 2, 2, 1072, 8346, 3, 2, 2, 2, 1074, 8359, 3, 2, 2, 2, 1076, 8371, 3, 2, 2, 2, 1078, 8373, 3, 2, 2, 2, 1080, 8376, 3, 2, 2, 2, 1082, 8390, 3, 2, 2, 2, 1084, 8395, 3, 2, 2, 2, 1086, 8400, 3, 2, 2, 2, 1088, 8410, 3, 2, 2, 2, 1090, 8414, 3, 2, 2, 2, 1092, 8416, 3, 2, 2, 2, 1094, 8424, 3, 2, 2, 2, 1096, 8428, 3, 2, 2, 2, 1098, 8449, 3, 2, 2, 2, 1100, 8457, 3, 2, 2, 2, 1102, 8467, 3, 2, 2, 2, 1104, 8479, 3, 2, 2, 2, 1106, 8481, 3, 2, 2, 2, 1108, 8495, 3, 2, 2, 2, 1110, 8515, 3, 2, 2, 2, 1112, 8524, 3, 2, 2, 2, 1114, 8540, 3, 2, 2, 2, 1116, 8546, 3, 2, 2, 2, 1118, 8548, 3, 2, 2, 2, 1120, 8559, 3, 2, 2, 2, 1122, 8577, 3, 2, 2, 2, 1124, 8584, 3, 2, 2, 2, 1126, 8588, 3, 2, 2, 2, 1128, 8592, 3, 2, 2, 2, 1130, 8594, 3, 2, 2, 2, 1132, 8600, 3, 2, 2, 2, 1134, 8603, 3, 2, 2, 2, 1136, 8610, 3, 2, 2, 2, 1138, 8623, 3, 2, 2, 2, 1140, 8627, 3, 2, 2, 2, 1142, 8629, 3, 2, 2, 2, 1144, 8638, 3, 2, 2, 2, 1146, 8647, 3, 2, 2, 2, 1148, 8675, 3, 2, 2, 2, 1150, 8677, 3, 2, 2, 2, 1152, 8687, 3, 2, 2, 2, 1154, 8689, 3, 2, 2, 2, 1156, 8691, 3, 2, 2, 2, 1158, 8695, 3, 2, 2, 2, 1160, 8703, 3, 2, 2, 2, 1162, 8711, 3, 2, 2, 2, 1164, 8719, 3, 2, 2, 2, 1166, 8728, 3, 2, 2, 2, 1168, 8732, 3, 2, 2, 2, 1170, 8736, 3, 2, 2, 2, 1172, 8762, 3, 2, 2, 2, 1174, 8776, 3, 2, 2, 2, 1176, 8795, 3, 2, 2, 2, 1178, 8805, 3, 2, 2, 2, 1180, 8809, 3, 2, 2, 2, 1182, 8817, 3, 2, 2, 2, 1184, 8825, 3, 2, 2, 2, 1186, 8831, 3, 2, 2, 2, 1188, 8835, 3, 2, 2, 2, 1190, 8842, 3, 2, 2, 2, 1192, 8847, 3, 2, 2, 2, 1194, 8862, 3, 2, 2, 2, 1196, 8942, 3, 2, 2, 2, 1198, 8944, 3, 2, 2, 2, 1200, 8946, 3, 2, 2, 2, 1202, 8976, 3, 2, 2, 2, 1204, 8980, 3, 2, 2, 2, 1206, 9159, 3, 2, 2, 2, 1208, 9166, 3, 2, 2, 2, 1210, 9179, 3, 2, 2, 2, 1212, 9181, 3, 2, 2, 2, 1214, 9186, 3, 2, 2, 2, 1216, 9194, 3, 2, 2, 2, 1218, 9199, 3, 2, 2, 2, 1220, 9206, 3, 2, 2, 2, 1222, 9223, 3, 2, 2, 2, 1224, 9225, 3, 2, 2, 2, 1226, 9235, 3, 2, 2, 2, 1228, 9244, 3, 2, 2, 2, 1230, 9249, 3, 2, 2, 2, 1232, 9251, 3, 2, 2, 2, 1234, 9259, 3, 2, 2, 2, 1236, 9269, 3, 2, 2, 2, 1238, 9271, 3, 2, 2, 2, 1240, 9280, 3, 2, 2, 2, 1242, 9286, 3, 2, 2, 2, 1244, 9301, 3, 2, 2, 2, 1246, 9309, 3, 2, 2, 2, 1248, 9318, 3, 2, 2, 2, 1250, 9330, 3, 2, 2, 2, 1252, 9344, 3, 2, 2, 2, 1254, 9346, 3, 2, 2, 2, 1256, 9353, 3, 2, 2, 2, 1258, 9359, 3, 2, 2, 2, 1260, 9363, 3, 2, 2, 2, 1262, 9365, 3, 2, 2, 2, 1264, 9373, 3, 2, 2, 2, 1266, 9381, 3, 2, 2, 2, 1268, 9395, 3, 2, 2, 2, 1270, 9397, 3, 2, 2, 2, 1272, 9405, 3, 2, 2, 2, 1274, 9418, 3, 2, 2, 2, 1276, 9420, 3, 2, 2, 2, 1278, 9428, 3, 2, 2, 2, 1280, 9435, 3, 2, 2, 2, 1282, 9448, 3, 2, 2, 2, 1284, 9458, 3, 2, 2, 2, 1286, 9460, 3, 2, 2, 2, 1288, 9462, 3, 2, 2, 2, 1290, 9476, 3, 2, 2, 2, 1292, 9506, 3, 2, 2, 2, 1294, 9515, 3, 2, 2, 2, 1296, 9522, 3, 2, 2, 2, 1298, 9524, 3, 2, 2, 2, 1300, 9531, 3, 2, 2, 2, 1302, 9535, 3, 2, 2, 2, 1304, 9543, 3, 2, 2, 2, 1306, 9547, 3, 2, 2, 2, 1308, 9549, 3, 2, 2, 2, 1310, 9568, 3, 2, 2, 2, 1312, 9572, 3, 2, 2, 2, 1314, 9575, 3, 2, 2, 2, 1316, 9582, 3, 2, 2, 2, 1318, 9587, 3, 2, 2, 2, 1320, 9589, 3, 2, 2, 2, 1322, 9605, 3, 2, 2, 2, 1324, 9607, 3, 2, 2, 2, 1326, 9615, 3, 2, 2, 2, 1328, 9619, 3, 2, 2, 2, 1330, 9627, 3, 2, 2, 2, 1332, 9629, 3, 2, 2, 2, 1334, 9631, 3, 2, 2, 2, 1336, 9637, 3, 2, 2, 2, 1338, 9671, 3, 2, 2, 2, 1340, 9673, 3, 2, 2, 2, 1342, 9675, 3, 2, 2, 2, 1344, 9677, 3, 2, 2, 2, 1346, 9679, 3, 2, 2, 2, 1348, 9681, 3, 2, 2, 2, 1350, 9695, 3, 2, 2, 2, 1352, 9700, 3, 2, 2, 2, 1354, 9707, 3, 2, 2, 2, 1356, 9709, 3, 2, 2, 2, 1358, 9714, 3, 2, 2, 2, 1360, 9716, 3, 2, 2, 2, 1362, 9728, 3, 2, 2, 2, 1364, 9734, 3, 2, 2, 2, 1366, 9740, 3, 2, 2, 2, 1368, 9748, 3, 2, 2, 2, 1370, 9757, 3, 2, 2, 2, 1372, 9759, 3, 2, 2, 2, 1374, 9761, 3, 2, 2, 2, 1376, 9814, 3, 2, 2, 2, 1378, 9816, 3, 2, 2, 2, 1380, 9818, 3, 2, 2, 2, 1382, 9820, 3, 2, 2, 2, 1384, 9827, 3, 2, 2, 2, 1386, 9850, 3, 2, 2, 2, 1388, 9852, 3, 2, 2, 2, 1390, 9858, 3, 2, 2, 2, 1392, 9862, 3, 2, 2, 2, 1394, 9864, 3, 2, 2, 2, 1396, 9871, 3, 2, 2, 2, 1398, 9878, 3, 2, 2, 2, 1400, 9881, 3, 2, 2, 2, 1402, 9885, 3, 2, 2, 2, 1404, 9892, 3, 2, 2, 2, 1406, 9894, 3, 2, 2, 2, 1408, 9918, 3, 2, 2, 2, 1410, 9920, 3, 2, 2, 2, 1412, 9927, 3, 2, 2, 2, 1414, 9929, 3, 2, 2, 2, 1416, 9937, 3, 2, 2, 2, 1418, 9940, 3, 2, 2, 2, 1420, 9944, 3, 2, 2, 2, 1422, 9946, 3, 2, 2, 2, 1424, 9950, 3, 2, 2, 2, 1426, 9952, 3, 2, 2, 2, 1428, 9957, 3, 2, 2, 2, 1430, 9962, 3, 2, 2, 2, 1432, 9968, 3, 2, 2, 2, 1434, 9972, 3, 2, 2, 2, 1436, 9974, 3, 2, 2, 2, 1438, 9979, 3, 2, 2, 2, 1440, 10009, 3, 2, 2, 2, 1442, 10011, 3, 2, 2, 2, 1444, 10029, 3, 2, 2, 2, 1446, 10033, 3, 2, 2, 2, 1448, 10035, 3, 2, 2, 2, 1450, 10040, 3, 2, 2, 2, 1452, 10049, 3, 2, 2, 2, 1454, 10051, 3, 2, 2, 2, 1456, 10059, 3, 2, 2, 2, 1458, 10063, 3, 2, 2, 2, 1460, 10065, 3, 2, 2, 2, 1462, 10069, 3, 2, 2, 2, 1464, 10080, 3, 2, 2, 2, 1466, 10097, 3, 2, 2, 2, 1468, 10103, 3, 2, 2, 2, 1470, 10105, 3, 2, 2, 2, 1472, 10115, 3, 2, 2, 2, 1474, 10118, 3, 2, 2, 2, 1476, 10122, 3, 2, 2, 2, 1478, 10130, 3, 2, 2, 2, 1480, 10132, 3, 2, 2, 2, 1482, 10135, 3, 2, 2, 2, 1484, 10140, 3, 2, 2, 2, 1486, 10145, 3, 2, 2, 2, 1488, 10167, 3, 2, 2, 2, 1490, 10181, 3, 2, 2, 2, 1492, 10185, 3, 2, 2, 2, 1494, 10190, 3, 2, 2, 2, 1496, 10192, 3, 2, 2, 2, 1498, 10194, 3, 2, 2, 2, 1500, 10206, 3, 2, 2, 2, 1502, 10208, 3, 2, 2, 2, 1504, 10213, 3, 2, 2, 2, 1506, 10215, 3, 2, 2, 2, 1508, 10233, 3, 2, 2, 2, 1510, 10261, 3, 2, 2, 2, 1512, 10271, 3, 2, 2, 2, 1514, 10280, 3, 2, 2, 2, 1516, 10285, 3, 2, 2, 2, 1518, 10287, 3, 2, 2, 2, 1520, 10291, 3, 2, 2, 2, 1522, 10299, 3, 2, 2, 2, 1524, 10307, 3, 2, 2, 2, 1526, 10309, 3, 2, 2, 2, 1528, 10316, 3, 2, 2, 2, 1530, 10319, 3, 2, 2, 2, 1532, 10335, 3, 2, 2, 2, 1534, 10337, 3, 2, 2, 2, 1536, 10351, 3, 2, 2, 2, 1538, 10353, 3, 2, 2, 2, 1540, 10380, 3, 2, 2, 2, 1542, 10382, 3, 2, 2, 2, 1544, 10393, 3, 2, 2, 2, 1546, 10399, 3, 2, 2, 2, 1548, 10403, 3, 2, 2, 2, 1550, 10405, 3, 2, 2, 2, 1552, 10413, 3, 2, 2, 2, 1554, 10418, 3, 2, 2, 2, 1556, 10437, 3, 2, 2, 2, 1558, 10439, 3, 2, 2, 2, 1560, 10444, 3, 2, 2, 2, 1562, 10448, 3, 2, 2, 2, 1564, 10451, 3, 2, 2, 2, 1566, 10455, 3, 2, 2, 2, 1568, 10465, 3, 2, 2, 2, 1570, 10479, 3, 2, 2, 2, 1572, 10483, 3, 2, 2, 2, 1574, 10488, 3, 2, 2, 2, 1576, 10491, 3, 2, 2, 2, 1578, 10495, 3, 2, 2, 2, 1580, 10500, 3, 2, 2, 2, 1582, 10511, 3, 2, 2, 2, 1584, 10515, 3, 2, 2, 2, 1586, 10519, 3, 2, 2, 2, 1588, 10523, 3, 2, 2, 2, 1590, 10528, 3, 2, 2, 2, 1592, 10532, 3, 2, 2, 2, 1594, 10534, 3, 2, 2, 2, 1596, 10536, 3, 2, 2, 2, 1598, 10544, 3, 2, 2, 2, 1600, 10546, 3, 2, 2, 2, 1602, 10548, 3, 2, 2, 2, 1604, 10550, 3, 2, 2, 2, 1606, 10552, 3, 2, 2, 2, 1608, 10560, 3, 2, 2, 2, 1610, 1611, 5, 6, 4, 2, 1611, 1612, 7, 2, 2, 3, 1612, 3, 3, 2, 2, 2, 1613, 1614, 5, 1382, 692, 2, 1614, 5, 3, 2, 2, 2, 1615, 1616, 5, 8, 5, 2, 1616, 7, 3, 2, 2, 2, 1617, 1619, 5, 10, 6, 2, 1618, 1620, 7, 9, 2, 2, 1619, 1618, 3, 2, 2, 2, 1619, 1620, 3, 2, 2, 2, 1620, 1622, 3, 2, 2, 2, 1621, 1617, 3, 2, 2, 2, 1622, 1625, 3, 2, 2, 2, 1623, 1621, 3, 2, 2, 2, 1623, 1624, 3, 2, 2, 2, 1624, 9, 3, 2, 2, 2, 1625, 1623, 3, 2, 2, 2, 1626, 1751, 5, 454, 228, 2, 1627, 1751, 5, 828, 415, 2, 1628, 1751, 5, 818, 410, 2, 1629, 1751, 5, 820, 411, 2, 1630, 1751, 5, 580, 291, 2, 1631, 1751, 5, 834, 418, 2, 1632, 1751, 5, 480, 241, 2, 1633, 1751, 5, 324, 163, 2, 1634, 1751, 5, 330, 166, 2, 1635, 1751, 5, 340, 171, 2, 1636, 1751, 5, 366, 184, 2, 1637, 1751, 5, 672, 337, 2, 1638, 1751, 5, 40, 21, 2, 1639, 1751, 5, 730, 366, 2, 1640, 1751, 5, 734, 368, 2, 1641, 1751, 5, 746, 374, 2, 1642, 1751, 5, 736, 369, 2, 1643, 1751, 5, 744, 373, 2, 1644, 1751, 5, 386, 194, 2, 1645, 1751, 5, 282, 142, 2, 1646, 1751, 5, 830, 416, 2, 1647, 1751, 5, 98, 50, 2, 1648, 1751, 5, 722, 362, 2, 1649, 1751, 5, 136, 69, 2, 1650, 1751, 5, 754, 378, 2, 1651, 1751, 5, 34, 18, 2, 1652, 1751, 5, 30, 16, 2, 1653, 1751, 5, 762, 382, 2, 1654, 1751, 5, 264, 133, 2, 1655, 1751, 5, 840, 421, 2, 1656, 1751, 5, 838, 420, 2, 1657, 1751, 5, 382, 192, 2, 1658, 1751, 5, 852, 427, 2, 1659, 1751, 5, 14, 8, 2, 1660, 1751, 5, 94, 48, 2, 1661, 1751, 5, 142, 72, 2, 1662, 1751, 5, 846, 424, 2, 1663, 1751, 5, 536, 269, 2, 1664, 1751, 5, 88, 45, 2, 1665, 1751, 5, 144, 73, 2, 1666, 1751, 5, 402, 202, 2, 1667, 1751, 5, 266, 134, 2, 1668, 1751, 5, 458, 230, 2, 1669, 1751, 5, 698, 350, 2, 1670, 1751, 5, 844, 423, 2, 1671, 1751, 5, 832, 417, 2, 1672, 1751, 5, 318, 160, 2, 1673, 1751, 5, 332, 167, 2, 1674, 1751, 5, 358, 180, 2, 1675, 1751, 5, 368, 185, 2, 1676, 1751, 5, 618, 310, 2, 1677, 1751, 5, 38, 20, 2, 1678, 1751, 5, 272, 137, 2, 1679, 1751, 5, 484, 243, 2, 1680, 1751, 5, 498, 250, 2, 1681, 1751, 5, 748, 375, 2, 1682, 1751, 5, 500, 251, 2, 1683, 1751, 5, 384, 193, 2, 1684, 1751, 5, 298, 150, 2, 1685, 1751, 5, 44, 23, 2, 1686, 1751, 5, 280, 141, 2, 1687, 1751, 5, 174, 88, 2, 1688, 1751, 5, 756, 379, 2, 1689, 1751, 5, 262, 132, 2, 1690, 1751, 5, 312, 157, 2, 1691, 1751, 5, 706, 354, 2, 1692, 1751, 5, 406, 204, 2, 1693, 1751, 5, 446, 224, 2, 1694, 1751, 5, 16, 9, 2, 1695, 1751, 5, 28, 15, 2, 1696, 1751, 5, 376, 189, 2, 1697, 1751, 5, 806, 404, 2, 1698, 1751, 5, 902, 452, 2, 1699, 1751, 5, 946, 474, 2, 1700, 1751, 5, 460, 231, 2, 1701, 1751, 5, 922, 462, 2, 1702, 1751, 5, 96, 49, 2, 1703, 1751, 5, 692, 347, 2, 1704, 1751, 5, 702, 352, 2, 1705, 1751, 5, 506, 254, 2, 1706, 1751, 5, 508, 255, 2, 1707, 1751, 5, 510, 256, 2, 1708, 1751, 5, 514, 258, 2, 1709, 1751, 5, 764, 383, 2, 1710, 1751, 5, 316, 159, 2, 1711, 1751, 5, 710, 356, 2, 1712, 1751, 5, 36, 19, 2, 1713, 1751, 5, 380, 191, 2, 1714, 1751, 5, 822, 412, 2, 1715, 1751, 5, 898, 450, 2, 1716, 1751, 5, 880, 441, 2, 1717, 1751, 5, 546, 274, 2, 1718, 1751, 5, 554, 278, 2, 1719, 1751, 5, 572, 287, 2, 1720, 1751, 5, 370, 186, 2, 1721, 1751, 5, 590, 296, 2, 1722, 1751, 5, 904, 453, 2, 1723, 1751, 5, 784, 393, 2, 1724, 1751, 5, 278, 140, 2, 1725, 1751, 5, 804, 403, 2, 1726, 1751, 5, 926, 464, 2, 1727, 1751, 5, 780, 391, 2, 1728, 1751, 5, 892, 447, 2, 1729, 1751, 5, 512, 257, 2, 1730, 1751, 5, 712, 357, 2, 1731, 1751, 5, 680, 341, 2, 1732, 1751, 5, 678, 340, 2, 1733, 1751, 5, 682, 342, 2, 1734, 1751, 5, 724, 363, 2, 1735, 1751, 5, 556, 279, 2, 1736, 1751, 5, 574, 288, 2, 1737, 1751, 5, 766, 384, 2, 1738, 1751, 5, 540, 271, 2, 1739, 1751, 5, 954, 478, 2, 1740, 1751, 5, 788, 395, 2, 1741, 1751, 5, 532, 267, 2, 1742, 1751, 5, 786, 394, 2, 1743, 1751, 5, 936, 469, 2, 1744, 1751, 5, 850, 426, 2, 1745, 1751, 5, 76, 39, 2, 1746, 1751, 5, 52, 27, 2, 1747, 1751, 5, 86, 44, 2, 1748, 1751, 5, 800, 401, 2, 1749, 1751, 5, 12, 7, 2, 1750, 1626, 3, 2, 2, 2, 1750, 1627, 3, 2, 2, 2, 1750, 1628, 3, 2, 2, 2, 1750, 1629, 3, 2, 2, 2, 1750, 1630, 3, 2, 2, 2, 1750, 1631, 3, 2, 2, 2, 1750, 1632, 3, 2, 2, 2, 1750, 1633, 3, 2, 2, 2, 1750, 1634, 3, 2, 2, 2, 1750, 1635, 3, 2, 2, 2, 1750, 1636, 3, 2, 2, 2, 1750, 1637, 3, 2, 2, 2, 1750, 1638, 3, 2, 2, 2, 1750, 1639, 3, 2, 2, 2, 1750, 1640, 3, 2, 2, 2, 1750, 1641, 3, 2, 2, 2, 1750, 1642, 3, 2, 2, 2, 1750, 1643, 3, 2, 2, 2, 1750, 1644, 3, 2, 2, 2, 1750, 1645, 3, 2, 2, 2, 1750, 1646, 3, 2, 2, 2, 1750, 1647, 3, 2, 2, 2, 1750, 1648, 3, 2, 2, 2, 1750, 1649, 3, 2, 2, 2, 1750, 1650, 3, 2, 2, 2, 1750, 1651, 3, 2, 2, 2, 1750, 1652, 3, 2, 2, 2, 1750, 1653, 3, 2, 2, 2, 1750, 1654, 3, 2, 2, 2, 1750, 1655, 3, 2, 2, 2, 1750, 1656, 3, 2, 2, 2, 1750, 1657, 3, 2, 2, 2, 1750, 1658, 3, 2, 2, 2, 1750, 1659, 3, 2, 2, 2, 1750, 1660, 3, 2, 2, 2, 1750, 1661, 3, 2, 2, 2, 1750, 1662, 3, 2, 2, 2, 1750, 1663, 3, 2, 2, 2, 1750, 1664, 3, 2, 2, 2, 1750, 1665, 3, 2, 2, 2, 1750, 1666, 3, 2, 2, 2, 1750, 1667, 3, 2, 2, 2, 1750, 1668, 3, 2, 2, 2, 1750, 1669, 3, 2, 2, 2, 1750, 1670, 3, 2, 2, 2, 1750, 1671, 3, 2, 2, 2, 1750, 1672, 3, 2, 2, 2, 1750, 1673, 3, 2, 2, 2, 1750, 1674, 3, 2, 2, 2, 1750, 1675, 3, 2, 2, 2, 1750, 1676, 3, 2, 2, 2, 1750, 1677, 3, 2, 2, 2, 1750, 1678, 3, 2, 2, 2, 1750, 1679, 3, 2, 2, 2, 1750, 1680, 3, 2, 2, 2, 1750, 1681, 3, 2, 2, 2, 1750, 1682, 3, 2, 2, 2, 1750, 1683, 3, 2, 2, 2, 1750, 1684, 3, 2, 2, 2, 1750, 1685, 3, 2, 2, 2, 1750, 1686, 3, 2, 2, 2, 1750, 1687, 3, 2, 2, 2, 1750, 1688, 3, 2, 2, 2, 1750, 1689, 3, 2, 2, 2, 1750, 1690, 3, 2, 2, 2, 1750, 1691, 3, 2, 2, 2, 1750, 1692, 3, 2, 2, 2, 1750, 1693, 3, 2, 2, 2, 1750, 1694, 3, 2, 2, 2, 1750, 1695, 3, 2, 2, 2, 1750, 1696, 3, 2, 2, 2, 1750, 1697, 3, 2, 2, 2, 1750, 1698, 3, 2, 2, 2, 1750, 1699, 3, 2, 2, 2, 1750, 1700, 3, 2, 2, 2, 1750, 1701, 3, 2, 2, 2, 1750, 1702, 3, 2, 2, 2, 1750, 1703, 3, 2, 2, 2, 1750, 1704, 3, 2, 2, 2, 1750, 1705, 3, 2, 2, 2, 1750, 1706, 3, 2, 2, 2, 1750, 1707, 3, 2, 2, 2, 1750, 1708, 3, 2, 2, 2, 1750, 1709, 3, 2, 2, 2, 1750, 1710, 3, 2, 2, 2, 1750, 1711, 3, 2, 2, 2, 1750, 1712, 3, 2, 2, 2, 1750, 1713, 3, 2, 2, 2, 1750, 1714, 3, 2, 2, 2, 1750, 1715, 3, 2, 2, 2, 1750, 1716, 3, 2, 2, 2, 1750, 1717, 3, 2, 2, 2, 1750, 1718, 3, 2, 2, 2, 1750, 1719, 3, 2, 2, 2, 1750, 1720, 3, 2, 2, 2, 1750, 1721, 3, 2, 2, 2, 1750, 1722, 3, 2, 2, 2, 1750, 1723, 3, 2, 2, 2, 1750, 1724, 3, 2, 2, 2, 1750, 1725, 3, 2, 2, 2, 1750, 1726, 3, 2, 2, 2, 1750, 1727, 3, 2, 2, 2, 1750, 1728, 3, 2, 2, 2, 1750, 1729, 3, 2, 2, 2, 1750, 1730, 3, 2, 2, 2, 1750, 1731, 3, 2, 2, 2, 1750, 1732, 3, 2, 2, 2, 1750, 1733, 3, 2, 2, 2, 1750, 1734, 3, 2, 2, 2, 1750, 1735, 3, 2, 2, 2, 1750, 1736, 3, 2, 2, 2, 1750, 1737, 3, 2, 2, 2, 1750, 1738, 3, 2, 2, 2, 1750, 1739, 3, 2, 2, 2, 1750, 1740, 3, 2, 2, 2, 1750, 1741, 3, 2, 2, 2, 1750, 1742, 3, 2, 2, 2, 1750, 1743, 3, 2, 2, 2, 1750, 1744, 3, 2, 2, 2, 1750, 1745, 3, 2, 2, 2, 1750, 1746, 3, 2, 2, 2, 1750, 1747, 3, 2, 2, 2, 1750, 1748, 3, 2, 2, 2, 1750, 1749, 3, 2, 2, 2, 1751, 11, 3, 2, 2, 2, 1752, 1754, 7, 546, 2, 2, 1753, 1755, 7, 547, 2, 2, 1754, 1753, 3, 2, 2, 2, 1754, 1755, 3, 2, 2, 2, 1755, 13, 3, 2, 2, 2, 1756, 1757, 7, 426, 2, 2, 1757, 1758, 5, 1200, 601, 2, 1758, 15, 3, 2, 2, 2, 1759, 1760, 7, 48, 2, 2, 1760, 1761, 7, 311, 2, 2, 1761, 1762, 5, 1356, 679, 2, 1762, 1763, 5, 18, 10, 2, 1763, 1764, 5, 20, 11, 2, 1764, 17, 3, 2, 2, 2, 1765, 1768, 7, 107, 2, 2, 1766, 1768, 3, 2, 2, 2, 1767, 1765, 3, 2, 2, 2, 1767, 1766, 3, 2, 2, 2, 1768, 19, 3, 2, 2, 2, 1769, 1771, 5, 26, 14, 2, 1770, 1769, 3, 2, 2, 2, 1771, 1774, 3, 2, 2, 2, 1772, 1770, 3, 2, 2, 2, 1772, 1773, 3, 2, 2, 2, 1773, 21, 3, 2, 2, 2, 1774, 1772, 3, 2, 2, 2, 1775, 1777, 5, 24, 13, 2, 1776, 1775, 3, 2, 2, 2, 1777, 1780, 3, 2, 2, 2, 1778, 1776, 3, 2, 2, 2, 1778, 1779, 3, 2, 2, 2, 1779, 23, 3, 2, 2, 2, 1780, 1778, 3, 2, 2, 2, 1781, 1784, 7, 280, 2, 2, 1782, 1785, 5, 1348, 675, 2, 1783, 1785, 7, 80, 2, 2, 1784, 1782, 3, 2, 2, 2, 1784, 1783, 3, 2, 2, 2, 1785, 1800, 3, 2, 2, 2, 1786, 1787, 9, 2, 2, 2, 1787, 1788, 7, 280, 2, 2, 1788, 1800, 5, 1348, 675, 2, 1789, 1800, 7, 230, 2, 2, 1790, 1791, 7, 166, 2, 2, 1791, 1792, 7, 76, 2, 2, 1792, 1800, 5, 1354, 678, 2, 1793, 1794, 7, 364, 2, 2, 1794, 1795, 7, 361, 2, 2, 1795, 1800, 5, 1348, 675, 2, 1796, 1797, 7, 101, 2, 2, 1797, 1800, 5, 1360, 681, 2, 1798, 1800, 5, 1370, 686, 2, 1799, 1781, 3, 2, 2, 2, 1799, 1786, 3, 2, 2, 2, 1799, 1789, 3, 2, 2, 2, 1799, 1790, 3, 2, 2, 2, 1799, 1793, 3, 2, 2, 2, 1799, 1796, 3, 2, 2, 2, 1799, 1798, 3, 2, 2, 2, 1800, 25, 3, 2, 2, 2, 1801, 1812, 5, 24, 13, 2, 1802, 1803, 7, 341, 2, 2, 1803, 1812, 5, 1346, 674, 2, 1804, 1805, 7, 136, 2, 2, 1805, 1812, 5, 1360, 681, 2, 1806, 1807, 7, 311, 2, 2, 1807, 1812, 5, 1360, 681, 2, 1808, 1809, 7, 70, 2, 2, 1809, 1810, 9, 3, 2, 2, 1810, 1812, 5, 1360, 681, 2, 1811, 1801, 3, 2, 2, 2, 1811, 1802, 3, 2, 2, 2, 1811, 1804, 3, 2, 2, 2, 1811, 1806, 3, 2, 2, 2, 1811, 1808, 3, 2, 2, 2, 1812, 27, 3, 2, 2, 2, 1813, 1814, 7, 48, 2, 2, 1814, 1815, 7, 101, 2, 2, 1815, 1816, 5, 1356, 679, 2, 1816, 1817, 5, 18, 10, 2, 1817, 1818, 5, 20, 11, 2, 1818, 29, 3, 2, 2, 2, 1819, 1820, 7, 140, 2, 2, 1820, 1821, 9, 4, 2, 2, 1821, 1822, 5, 1358, 680, 2, 1822, 1823, 5, 18, 10, 2, 1823, 1824, 5, 22, 12, 2, 1824, 31, 3, 2, 2, 2, 1825, 1830, 3, 2, 2, 2, 1826, 1827, 7, 70, 2, 2, 1827, 1828, 7, 177, 2, 2, 1828, 1830, 5, 1330, 666, 2, 1829, 1825, 3, 2, 2, 2, 1829, 1826, 3, 2, 2, 2, 1830, 33, 3, 2, 2, 2, 1831, 1832, 7, 140, 2, 2, 1832, 1834, 9, 4, 2, 2, 1833, 1835, 7, 32, 2, 2, 1834, 1833, 3, 2, 2, 2, 1834, 1835, 3, 2, 2, 2, 1835, 1836, 3, 2, 2, 2, 1836, 1837, 5, 1358, 680, 2, 1837, 1838, 5, 32, 17, 2, 1838, 1839, 5, 82, 42, 2, 1839, 35, 3, 2, 2, 2, 1840, 1841, 7, 193, 2, 2, 1841, 1844, 9, 5, 2, 2, 1842, 1843, 7, 222, 2, 2, 1843, 1845, 7, 389, 2, 2, 1844, 1842, 3, 2, 2, 2, 1844, 1845, 3, 2, 2, 2, 1845, 1846, 3, 2, 2, 2, 1846, 1847, 5, 1360, 681, 2, 1847, 37, 3, 2, 2, 2, 1848, 1849, 7, 48, 2, 2, 1849, 1850, 7, 68, 2, 2, 1850, 1851, 5, 1356, 679, 2, 1851, 1852, 5, 18, 10, 2, 1852, 1853, 5, 20, 11, 2, 1853, 39, 3, 2, 2, 2, 1854, 1855, 7, 140, 2, 2, 1855, 1856, 7, 68, 2, 2, 1856, 1857, 5, 1358, 680, 2, 1857, 1858, 5, 42, 22, 2, 1858, 1859, 7, 101, 2, 2, 1859, 1860, 5, 1360, 681, 2, 1860, 41, 3, 2, 2, 2, 1861, 1862, 9, 6, 2, 2, 1862, 43, 3, 2, 2, 2, 1863, 1864, 7, 48, 2, 2, 1864, 1868, 7, 316, 2, 2, 1865, 1866, 7, 222, 2, 2, 1866, 1867, 7, 79, 2, 2, 1867, 1869, 7, 389, 2, 2, 1868, 1865, 3, 2, 2, 2, 1868, 1869, 3, 2, 2, 2, 1869, 1875, 3, 2, 2, 2, 1870, 1871, 5, 46, 24, 2, 1871, 1872, 7, 108, 2, 2, 1872, 1873, 5, 1358, 680, 2, 1873, 1876, 3, 2, 2, 2, 1874, 1876, 5, 1362, 682, 2, 1875, 1870, 3, 2, 2, 2, 1875, 1874, 3, 2, 2, 2, 1876, 1877, 3, 2, 2, 2, 1877, 1878, 5, 48, 25, 2, 1878, 45, 3, 2, 2, 2, 1879, 1882, 5, 1362, 682, 2, 1880, 1882, 3, 2, 2, 2, 1881, 1879, 3, 2, 2, 2, 1881, 1880, 3, 2, 2, 2, 1882, 47, 3, 2, 2, 2, 1883, 1885, 5, 50, 26, 2, 1884, 1883, 3, 2, 2, 2, 1885, 1888, 3, 2, 2, 2, 1886, 1884, 3, 2, 2, 2, 1886, 1887, 3, 2, 2, 2, 1887, 49, 3, 2, 2, 2, 1888, 1886, 3, 2, 2, 2, 1889, 1896, 5, 174, 88, 2, 1890, 1896, 5, 590, 296, 2, 1891, 1896, 5, 280, 141, 2, 1892, 1896, 5, 406, 204, 2, 1893, 1896, 5, 554, 278, 2, 1894, 1896, 5, 800, 401, 2, 1895, 1889, 3, 2, 2, 2, 1895, 1890, 3, 2, 2, 2, 1895, 1891, 3, 2, 2, 2, 1895, 1892, 3, 2, 2, 2, 1895, 1893, 3, 2, 2, 2, 1895, 1894, 3, 2, 2, 2, 1896, 51, 3, 2, 2, 2, 1897, 1899, 7, 326, 2, 2, 1898, 1900, 9, 7, 2, 2, 1899, 1898, 3, 2, 2, 2, 1899, 1900, 3, 2, 2, 2, 1900, 1901, 3, 2, 2, 2, 1901, 1902, 5, 54, 28, 2, 1902, 53, 3, 2, 2, 2, 1903, 1904, 7, 349, 2, 2, 1904, 1912, 5, 794, 398, 2, 1905, 1906, 7, 325, 2, 2, 1906, 1907, 7, 156, 2, 2, 1907, 1908, 7, 38, 2, 2, 1908, 1909, 7, 349, 2, 2, 1909, 1912, 5, 794, 398, 2, 1910, 1912, 5, 58, 30, 2, 1911, 1903, 3, 2, 2, 2, 1911, 1905, 3, 2, 2, 2, 1911, 1910, 3, 2, 2, 2, 1912, 55, 3, 2, 2, 2, 1913, 1914, 5, 60, 31, 2, 1914, 1915, 9, 8, 2, 2, 1915, 1916, 5, 62, 32, 2, 1916, 57, 3, 2, 2, 2, 1917, 1943, 5, 56, 29, 2, 1918, 1919, 5, 60, 31, 2, 1919, 1920, 7, 66, 2, 2, 1920, 1921, 7, 427, 2, 2, 1921, 1943, 3, 2, 2, 2, 1922, 1923, 7, 411, 2, 2, 1923, 1924, 7, 379, 2, 2, 1924, 1943, 5, 70, 36, 2, 1925, 1926, 7, 154, 2, 2, 1926, 1943, 5, 1348, 675, 2, 1927, 1928, 7, 316, 2, 2, 1928, 1943, 5, 1348, 675, 2, 1929, 1930, 7, 260, 2, 2, 1930, 1943, 5, 72, 37, 2, 1931, 1932, 7, 311, 2, 2, 1932, 1943, 5, 74, 38, 2, 1933, 1934, 7, 325, 2, 2, 1934, 1935, 7, 108, 2, 2, 1935, 1943, 5, 74, 38, 2, 1936, 1937, 7, 376, 2, 2, 1937, 1938, 7, 272, 2, 2, 1938, 1943, 5, 1218, 610, 2, 1939, 1940, 7, 349, 2, 2, 1940, 1941, 7, 330, 2, 2, 1941, 1943, 5, 1348, 675, 2, 1942, 1917, 3, 2, 2, 2, 1942, 1918, 3, 2, 2, 2, 1942, 1922, 3, 2, 2, 2, 1942, 1925, 3, 2, 2, 2, 1942, 1927, 3, 2, 2, 2, 1942, 1929, 3, 2, 2, 2, 1942, 1931, 3, 2, 2, 2, 1942, 1933, 3, 2, 2, 2, 1942, 1936, 3, 2, 2, 2, 1942, 1939, 3, 2, 2, 2, 1943, 59, 3, 2, 2, 2, 1944, 1949, 5, 1362, 682, 2, 1945, 1946, 7, 13, 2, 2, 1946, 1948, 5, 1362, 682, 2, 1947, 1945, 3, 2, 2, 2, 1948, 1951, 3, 2, 2, 2, 1949, 1947, 3, 2, 2, 2, 1949, 1950, 3, 2, 2, 2, 1950, 61, 3, 2, 2, 2, 1951, 1949, 3, 2, 2, 2, 1952, 1957, 5, 64, 33, 2, 1953, 1954, 7, 8, 2, 2, 1954, 1956, 5, 64, 33, 2, 1955, 1953, 3, 2, 2, 2, 1956, 1959, 3, 2, 2, 2, 1957, 1955, 3, 2, 2, 2, 1957, 1958, 3, 2, 2, 2, 1958, 63, 3, 2, 2, 2, 1959, 1957, 3, 2, 2, 2, 1960, 1963, 5, 68, 35, 2, 1961, 1963, 5, 294, 148, 2, 1962, 1960, 3, 2, 2, 2, 1962, 1961, 3, 2, 2, 2, 1963, 65, 3, 2, 2, 2, 1964, 1965, 7, 293, 2, 2, 1965, 1970, 9, 9, 2, 2, 1966, 1967, 7, 303, 2, 2, 1967, 1970, 7, 293, 2, 2, 1968, 1970, 7, 323, 2, 2, 1969, 1964, 3, 2, 2, 2, 1969, 1966, 3, 2, 2, 2, 1969, 1968, 3, 2, 2, 2, 1970, 67, 3, 2, 2, 2, 1971, 1976, 7, 98, 2, 2, 1972, 1976, 7, 62, 2, 2, 1973, 1976, 7, 82, 2, 2, 1974, 1976, 5, 74, 38, 2, 1975, 1971, 3, 2, 2, 2, 1975, 1972, 3, 2, 2, 2, 1975, 1973, 3, 2, 2, 2, 1975, 1974, 3, 2, 2, 2, 1976, 69, 3, 2, 2, 2, 1977, 1993, 5, 1348, 675, 2, 1978, 1993, 5, 1370, 686, 2, 1979, 1980, 5, 1144, 573, 2, 1980, 1981, 5, 1348, 675, 2, 1981, 1982, 5, 1148, 575, 2, 1982, 1993, 3, 2, 2, 2, 1983, 1984, 5, 1144, 573, 2, 1984, 1985, 7, 4, 2, 2, 1985, 1986, 5, 1346, 674, 2, 1986, 1987, 7, 5, 2, 2, 1987, 1988, 5, 1348, 675, 2, 1988, 1993, 3, 2, 2, 2, 1989, 1993, 5, 294, 148, 2, 1990, 1993, 7, 55, 2, 2, 1991, 1993, 7, 247, 2, 2, 1992, 1977, 3, 2, 2, 2, 1992, 1978, 3, 2, 2, 2, 1992, 1979, 3, 2, 2, 2, 1992, 1983, 3, 2, 2, 2, 1992, 1989, 3, 2, 2, 2, 1992, 1990, 3, 2, 2, 2, 1992, 1991, 3, 2, 2, 2, 1993, 71, 3, 2, 2, 2, 1994, 1998, 5, 1348, 675, 2, 1995, 1998, 7, 55, 2, 2, 1996, 1998, 3, 2, 2, 2, 1997, 1994, 3, 2, 2, 2, 1997, 1995, 3, 2, 2, 2, 1997, 1996, 3, 2, 2, 2, 1998, 73, 3, 2, 2, 2, 1999, 2002, 5, 1366, 684, 2, 2000, 2002, 5, 1348, 675, 2, 2001, 1999, 3, 2, 2, 2, 2001, 2000, 3, 2, 2, 2, 2002, 75, 3, 2, 2, 2, 2003, 2004, 7, 306, 2, 2, 2004, 2005, 5, 78, 40, 2, 2005, 77, 3, 2, 2, 2, 2006, 2015, 5, 80, 41, 2, 2007, 2008, 7, 411, 2, 2, 2008, 2015, 7, 379, 2, 2, 2009, 2010, 7, 349, 2, 2, 2010, 2011, 7, 237, 2, 2, 2011, 2015, 7, 244, 2, 2, 2012, 2013, 7, 325, 2, 2, 2013, 2015, 7, 108, 2, 2, 2014, 2006, 3, 2, 2, 2, 2014, 2007, 3, 2, 2, 2, 2014, 2009, 3, 2, 2, 2, 2014, 2012, 3, 2, 2, 2, 2015, 79, 3, 2, 2, 2, 2016, 2019, 5, 60, 31, 2, 2017, 2019, 7, 32, 2, 2, 2018, 2016, 3, 2, 2, 2, 2018, 2017, 3, 2, 2, 2, 2019, 81, 3, 2, 2, 2, 2020, 2021, 7, 326, 2, 2, 2021, 2024, 5, 54, 28, 2, 2022, 2024, 5, 76, 39, 2, 2023, 2020, 3, 2, 2, 2, 2023, 2022, 3, 2, 2, 2, 2024, 83, 3, 2, 2, 2, 2025, 2026, 7, 326, 2, 2, 2026, 2029, 5, 58, 30, 2, 2027, 2029, 5, 76, 39, 2, 2028, 2025, 3, 2, 2, 2, 2028, 2027, 3, 2, 2, 2, 2029, 85, 3, 2, 2, 2, 2030, 2040, 7, 328, 2, 2, 2031, 2041, 5, 60, 31, 2, 2032, 2033, 7, 411, 2, 2, 2033, 2041, 7, 379, 2, 2, 2034, 2035, 7, 349, 2, 2, 2035, 2036, 7, 237, 2, 2, 2036, 2041, 7, 244, 2, 2, 2037, 2038, 7, 325, 2, 2, 2038, 2041, 7, 108, 2, 2, 2039, 2041, 7, 32, 2, 2, 2040, 2031, 3, 2, 2, 2, 2040, 2032, 3, 2, 2, 2, 2040, 2034, 3, 2, 2, 2, 2040, 2037, 3, 2, 2, 2, 2040, 2039, 3, 2, 2, 2, 2041, 87, 3, 2, 2, 2, 2042, 2043, 7, 326, 2, 2, 2043, 2044, 7, 167, 2, 2, 2044, 2045, 5, 90, 46, 2, 2045, 2046, 5, 92, 47, 2, 2046, 89, 3, 2, 2, 2, 2047, 2050, 7, 32, 2, 2, 2048, 2050, 5, 1324, 663, 2, 2049, 2047, 3, 2, 2, 2, 2049, 2048, 3, 2, 2, 2, 2050, 91, 3, 2, 2, 2, 2051, 2052, 9, 10, 2, 2, 2052, 93, 3, 2, 2, 2, 2053, 2054, 7, 157, 2, 2, 2054, 95, 3, 2, 2, 2, 2055, 2056, 7, 189, 2, 2, 2056, 2057, 9, 11, 2, 2, 2057, 97, 3, 2, 2, 2, 2058, 2059, 7, 140, 2, 2, 2059, 2062, 7, 94, 2, 2, 2060, 2061, 7, 222, 2, 2, 2061, 2063, 7, 389, 2, 2, 2062, 2060, 3, 2, 2, 2, 2062, 2063, 3, 2, 2, 2, 2063, 2064, 3, 2, 2, 2, 2064, 2067, 5, 1066, 534, 2, 2065, 2068, 5, 100, 51, 2, 2066, 2068, 5, 102, 52, 2, 2067, 2065, 3, 2, 2, 2, 2067, 2066, 3, 2, 2, 2, 2068, 2168, 3, 2, 2, 2, 2069, 2070, 7, 140, 2, 2, 2070, 2071, 7, 94, 2, 2, 2071, 2072, 7, 32, 2, 2, 2072, 2073, 7, 70, 2, 2, 2073, 2074, 7, 344, 2, 2, 2074, 2078, 5, 1330, 666, 2, 2075, 2076, 7, 274, 2, 2, 2076, 2077, 7, 149, 2, 2, 2077, 2079, 5, 1360, 681, 2, 2078, 2075, 3, 2, 2, 2, 2078, 2079, 3, 2, 2, 2, 2079, 2080, 3, 2, 2, 2, 2080, 2081, 7, 326, 2, 2, 2081, 2082, 7, 344, 2, 2, 2082, 2083, 5, 1330, 666, 2, 2083, 2084, 5, 932, 467, 2, 2084, 2168, 3, 2, 2, 2, 2085, 2086, 7, 140, 2, 2, 2086, 2089, 7, 228, 2, 2, 2087, 2088, 7, 222, 2, 2, 2088, 2090, 7, 389, 2, 2, 2089, 2087, 3, 2, 2, 2, 2089, 2090, 3, 2, 2, 2, 2090, 2091, 3, 2, 2, 2, 2091, 2094, 5, 1326, 664, 2, 2092, 2095, 5, 100, 51, 2, 2093, 2095, 5, 104, 53, 2, 2094, 2092, 3, 2, 2, 2, 2094, 2093, 3, 2, 2, 2, 2095, 2168, 3, 2, 2, 2, 2096, 2097, 7, 140, 2, 2, 2097, 2098, 7, 228, 2, 2, 2098, 2099, 7, 32, 2, 2, 2099, 2100, 7, 70, 2, 2, 2100, 2101, 7, 344, 2, 2, 2101, 2105, 5, 1330, 666, 2, 2102, 2103, 7, 274, 2, 2, 2103, 2104, 7, 149, 2, 2, 2104, 2106, 5, 1360, 681, 2, 2105, 2102, 3, 2, 2, 2, 2105, 2106, 3, 2, 2, 2, 2106, 2107, 3, 2, 2, 2, 2107, 2108, 7, 326, 2, 2, 2108, 2109, 7, 344, 2, 2, 2109, 2110, 5, 1330, 666, 2, 2110, 2111, 5, 932, 467, 2, 2111, 2168, 3, 2, 2, 2, 2112, 2113, 7, 140, 2, 2, 2113, 2116, 7, 321, 2, 2, 2114, 2115, 7, 222, 2, 2, 2115, 2117, 7, 389, 2, 2, 2116, 2114, 3, 2, 2, 2, 2116, 2117, 3, 2, 2, 2, 2117, 2118, 3, 2, 2, 2, 2118, 2119, 5, 1326, 664, 2, 2119, 2120, 5, 100, 51, 2, 2120, 2168, 3, 2, 2, 2, 2121, 2122, 7, 140, 2, 2, 2122, 2125, 7, 369, 2, 2, 2123, 2124, 7, 222, 2, 2, 2124, 2126, 7, 389, 2, 2, 2125, 2123, 3, 2, 2, 2, 2125, 2126, 3, 2, 2, 2, 2126, 2127, 3, 2, 2, 2, 2127, 2128, 5, 1326, 664, 2, 2128, 2129, 5, 100, 51, 2, 2129, 2168, 3, 2, 2, 2, 2130, 2131, 7, 140, 2, 2, 2131, 2132, 7, 252, 2, 2, 2132, 2135, 7, 369, 2, 2, 2133, 2134, 7, 222, 2, 2, 2134, 2136, 7, 389, 2, 2, 2135, 2133, 3, 2, 2, 2, 2135, 2136, 3, 2, 2, 2, 2136, 2137, 3, 2, 2, 2, 2137, 2138, 5, 1326, 664, 2, 2138, 2139, 5, 100, 51, 2, 2139, 2168, 3, 2, 2, 2, 2140, 2141, 7, 140, 2, 2, 2141, 2142, 7, 252, 2, 2, 2142, 2143, 7, 369, 2, 2, 2143, 2144, 7, 32, 2, 2, 2144, 2145, 7, 70, 2, 2, 2145, 2146, 7, 344, 2, 2, 2146, 2150, 5, 1330, 666, 2, 2147, 2148, 7, 274, 2, 2, 2148, 2149, 7, 149, 2, 2, 2149, 2151, 5, 1360, 681, 2, 2150, 2147, 3, 2, 2, 2, 2150, 2151, 3, 2, 2, 2, 2151, 2152, 3, 2, 2, 2, 2152, 2153, 7, 326, 2, 2, 2153, 2154, 7, 344, 2, 2, 2154, 2155, 5, 1330, 666, 2, 2155, 2156, 5, 932, 467, 2, 2156, 2168, 3, 2, 2, 2, 2157, 2158, 7, 140, 2, 2, 2158, 2159, 7, 65, 2, 2, 2159, 2162, 7, 94, 2, 2, 2160, 2161, 7, 222, 2, 2, 2161, 2163, 7, 389, 2, 2, 2162, 2160, 3, 2, 2, 2, 2162, 2163, 3, 2, 2, 2, 2163, 2164, 3, 2, 2, 2, 2164, 2165, 5, 1066, 534, 2, 2165, 2166, 5, 100, 51, 2, 2166, 2168, 3, 2, 2, 2, 2167, 2058, 3, 2, 2, 2, 2167, 2069, 3, 2, 2, 2, 2167, 2085, 3, 2, 2, 2, 2167, 2096, 3, 2, 2, 2, 2167, 2112, 3, 2, 2, 2, 2167, 2121, 3, 2, 2, 2, 2167, 2130, 3, 2, 2, 2, 2167, 2140, 3, 2, 2, 2, 2167, 2157, 3, 2, 2, 2, 2168, 99, 3, 2, 2, 2, 2169, 2174, 5, 106, 54, 2, 2170, 2171, 7, 8, 2, 2, 2171, 2173, 5, 106, 54, 2, 2172, 2170, 3, 2, 2, 2, 2173, 2176, 3, 2, 2, 2, 2174, 2172, 3, 2, 2, 2, 2174, 2175, 3, 2, 2, 2, 2175, 101, 3, 2, 2, 2, 2176, 2174, 3, 2, 2, 2, 2177, 2178, 7, 428, 2, 2, 2178, 2179, 7, 278, 2, 2, 2179, 2180, 5, 1326, 664, 2, 2180, 2181, 5, 130, 66, 2, 2181, 2186, 3, 2, 2, 2, 2182, 2183, 7, 429, 2, 2, 2183, 2184, 7, 278, 2, 2, 2184, 2186, 5, 1326, 664, 2, 2185, 2177, 3, 2, 2, 2, 2185, 2182, 3, 2, 2, 2, 2186, 103, 3, 2, 2, 2, 2187, 2188, 7, 428, 2, 2, 2188, 2189, 7, 278, 2, 2, 2189, 2190, 5, 1326, 664, 2, 2190, 105, 3, 2, 2, 2, 2191, 2192, 7, 135, 2, 2, 2192, 2444, 5, 190, 96, 2, 2193, 2194, 7, 135, 2, 2, 2194, 2195, 7, 222, 2, 2, 2195, 2196, 7, 79, 2, 2, 2196, 2197, 7, 389, 2, 2, 2197, 2444, 5, 190, 96, 2, 2198, 2199, 7, 135, 2, 2, 2199, 2200, 7, 46, 2, 2, 2200, 2444, 5, 190, 96, 2, 2201, 2202, 7, 135, 2, 2, 2202, 2203, 7, 46, 2, 2, 2203, 2204, 7, 222, 2, 2, 2204, 2205, 7, 79, 2, 2, 2205, 2206, 7, 389, 2, 2, 2206, 2444, 5, 190, 96, 2, 2207, 2208, 7, 140, 2, 2, 2208, 2209, 5, 726, 364, 2, 2209, 2210, 5, 1362, 682, 2, 2210, 2211, 5, 108, 55, 2, 2211, 2444, 3, 2, 2, 2, 2212, 2213, 7, 140, 2, 2, 2213, 2214, 5, 726, 364, 2, 2214, 2215, 5, 1362, 682, 2, 2215, 2216, 7, 193, 2, 2, 2216, 2217, 7, 79, 2, 2, 2217, 2218, 7, 80, 2, 2, 2218, 2444, 3, 2, 2, 2, 2219, 2220, 7, 140, 2, 2, 2220, 2221, 5, 726, 364, 2, 2221, 2222, 5, 1362, 682, 2, 2222, 2223, 7, 326, 2, 2, 2223, 2224, 7, 79, 2, 2, 2224, 2225, 7, 80, 2, 2, 2225, 2444, 3, 2, 2, 2, 2226, 2227, 7, 140, 2, 2, 2227, 2228, 5, 726, 364, 2, 2228, 2229, 5, 1362, 682, 2, 2229, 2230, 7, 193, 2, 2, 2230, 2231, 7, 430, 2, 2, 2231, 2444, 3, 2, 2, 2, 2232, 2233, 7, 140, 2, 2, 2233, 2234, 5, 726, 364, 2, 2234, 2235, 5, 1362, 682, 2, 2235, 2236, 7, 193, 2, 2, 2236, 2237, 7, 430, 2, 2, 2237, 2238, 7, 222, 2, 2, 2238, 2239, 7, 389, 2, 2, 2239, 2444, 3, 2, 2, 2, 2240, 2241, 7, 140, 2, 2, 2241, 2242, 5, 726, 364, 2, 2242, 2243, 5, 1362, 682, 2, 2243, 2244, 7, 326, 2, 2, 2244, 2245, 7, 335, 2, 2, 2245, 2246, 5, 1354, 678, 2, 2246, 2444, 3, 2, 2, 2, 2247, 2248, 7, 140, 2, 2, 2248, 2249, 5, 726, 364, 2, 2249, 2250, 5, 1346, 674, 2, 2250, 2251, 7, 326, 2, 2, 2251, 2252, 7, 335, 2, 2, 2252, 2253, 5, 1354, 678, 2, 2253, 2444, 3, 2, 2, 2, 2254, 2255, 7, 140, 2, 2, 2255, 2256, 5, 726, 364, 2, 2256, 2257, 5, 1362, 682, 2, 2257, 2258, 7, 326, 2, 2, 2258, 2259, 5, 118, 60, 2, 2259, 2444, 3, 2, 2, 2, 2260, 2261, 7, 140, 2, 2, 2261, 2262, 5, 726, 364, 2, 2262, 2263, 5, 1362, 682, 2, 2263, 2264, 7, 306, 2, 2, 2264, 2265, 5, 118, 60, 2, 2265, 2444, 3, 2, 2, 2, 2266, 2267, 7, 140, 2, 2, 2267, 2268, 5, 726, 364, 2, 2268, 2269, 5, 1362, 682, 2, 2269, 2270, 7, 326, 2, 2, 2270, 2271, 7, 338, 2, 2, 2271, 2272, 5, 1362, 682, 2, 2272, 2444, 3, 2, 2, 2, 2273, 2274, 7, 140, 2, 2, 2274, 2275, 5, 726, 364, 2, 2275, 2276, 5, 1362, 682, 2, 2276, 2277, 7, 135, 2, 2, 2277, 2278, 7, 431, 2, 2, 2278, 2279, 5, 200, 101, 2, 2279, 2280, 7, 38, 2, 2, 2280, 2281, 7, 221, 2, 2, 2281, 2282, 5, 286, 144, 2, 2282, 2444, 3, 2, 2, 2, 2283, 2284, 7, 140, 2, 2, 2284, 2285, 5, 726, 364, 2, 2285, 2286, 5, 1362, 682, 2, 2286, 2287, 5, 126, 64, 2, 2287, 2444, 3, 2, 2, 2, 2288, 2289, 7, 140, 2, 2, 2289, 2290, 5, 726, 364, 2, 2290, 2291, 5, 1362, 682, 2, 2291, 2292, 7, 193, 2, 2, 2292, 2293, 7, 221, 2, 2, 2293, 2444, 3, 2, 2, 2, 2294, 2295, 7, 140, 2, 2, 2295, 2296, 5, 726, 364, 2, 2296, 2297, 5, 1362, 682, 2, 2297, 2298, 7, 193, 2, 2, 2298, 2299, 7, 221, 2, 2, 2299, 2300, 7, 222, 2, 2, 2300, 2301, 7, 389, 2, 2, 2301, 2444, 3, 2, 2, 2, 2302, 2303, 7, 193, 2, 2, 2303, 2304, 5, 726, 364, 2, 2304, 2305, 7, 222, 2, 2, 2305, 2306, 7, 389, 2, 2, 2306, 2307, 5, 1362, 682, 2, 2307, 2308, 5, 110, 56, 2, 2308, 2444, 3, 2, 2, 2, 2309, 2310, 7, 193, 2, 2, 2310, 2311, 5, 726, 364, 2, 2311, 2312, 5, 1362, 682, 2, 2312, 2313, 5, 110, 56, 2, 2313, 2444, 3, 2, 2, 2, 2314, 2315, 7, 140, 2, 2, 2315, 2316, 5, 726, 364, 2, 2316, 2317, 5, 1362, 682, 2, 2317, 2318, 5, 728, 365, 2, 2318, 2319, 7, 353, 2, 2, 2319, 2320, 5, 1110, 556, 2, 2320, 2321, 5, 112, 57, 2, 2321, 2322, 5, 114, 58, 2, 2322, 2444, 3, 2, 2, 2, 2323, 2324, 7, 140, 2, 2, 2324, 2325, 5, 726, 364, 2, 2325, 2326, 5, 1362, 682, 2, 2326, 2327, 5, 346, 174, 2, 2327, 2444, 3, 2, 2, 2, 2328, 2329, 7, 135, 2, 2, 2329, 2444, 5, 210, 106, 2, 2330, 2331, 7, 140, 2, 2, 2331, 2332, 7, 47, 2, 2, 2332, 2333, 5, 1330, 666, 2, 2333, 2334, 5, 442, 222, 2, 2334, 2444, 3, 2, 2, 2, 2335, 2336, 7, 365, 2, 2, 2336, 2337, 7, 47, 2, 2, 2337, 2444, 5, 1330, 666, 2, 2338, 2339, 7, 193, 2, 2, 2339, 2340, 7, 47, 2, 2, 2340, 2341, 7, 222, 2, 2, 2341, 2342, 7, 389, 2, 2, 2342, 2343, 5, 1330, 666, 2, 2343, 2344, 5, 110, 56, 2, 2344, 2444, 3, 2, 2, 2, 2345, 2346, 7, 193, 2, 2, 2346, 2347, 7, 47, 2, 2, 2347, 2348, 5, 1330, 666, 2, 2348, 2349, 5, 110, 56, 2, 2349, 2444, 3, 2, 2, 2, 2350, 2351, 7, 326, 2, 2, 2351, 2352, 7, 372, 2, 2, 2352, 2444, 7, 270, 2, 2, 2353, 2354, 7, 160, 2, 2, 2354, 2355, 7, 82, 2, 2, 2355, 2444, 5, 1330, 666, 2, 2356, 2357, 7, 326, 2, 2, 2357, 2358, 7, 372, 2, 2, 2358, 2444, 7, 160, 2, 2, 2359, 2360, 7, 326, 2, 2, 2360, 2444, 7, 432, 2, 2, 2361, 2362, 7, 326, 2, 2, 2362, 2444, 7, 360, 2, 2, 2363, 2364, 7, 195, 2, 2, 2364, 2365, 7, 350, 2, 2, 2365, 2444, 5, 1330, 666, 2, 2366, 2367, 7, 195, 2, 2, 2367, 2368, 7, 141, 2, 2, 2368, 2369, 7, 350, 2, 2, 2369, 2444, 5, 1330, 666, 2, 2370, 2371, 7, 195, 2, 2, 2371, 2372, 7, 305, 2, 2, 2372, 2373, 7, 350, 2, 2, 2373, 2444, 5, 1330, 666, 2, 2374, 2375, 7, 195, 2, 2, 2375, 2376, 7, 350, 2, 2, 2376, 2444, 7, 32, 2, 2, 2377, 2378, 7, 195, 2, 2, 2378, 2379, 7, 350, 2, 2, 2379, 2444, 7, 101, 2, 2, 2380, 2381, 7, 188, 2, 2, 2381, 2382, 7, 350, 2, 2, 2382, 2444, 5, 1330, 666, 2, 2383, 2384, 7, 188, 2, 2, 2384, 2385, 7, 350, 2, 2, 2385, 2444, 7, 32, 2, 2, 2386, 2387, 7, 188, 2, 2, 2387, 2388, 7, 350, 2, 2, 2388, 2444, 7, 101, 2, 2, 2389, 2390, 7, 195, 2, 2, 2390, 2391, 7, 314, 2, 2, 2391, 2444, 5, 1330, 666, 2, 2392, 2393, 7, 195, 2, 2, 2393, 2394, 7, 141, 2, 2, 2394, 2395, 7, 314, 2, 2, 2395, 2444, 5, 1330, 666, 2, 2396, 2397, 7, 195, 2, 2, 2397, 2398, 7, 305, 2, 2, 2398, 2399, 7, 314, 2, 2, 2399, 2444, 5, 1330, 666, 2, 2400, 2401, 7, 188, 2, 2, 2401, 2402, 7, 314, 2, 2, 2402, 2444, 5, 1330, 666, 2, 2403, 2404, 7, 230, 2, 2, 2404, 2444, 5, 1326, 664, 2, 2405, 2406, 7, 262, 2, 2, 2406, 2407, 7, 230, 2, 2, 2407, 2444, 5, 1326, 664, 2, 2408, 2409, 7, 268, 2, 2, 2409, 2444, 5, 526, 264, 2, 2410, 2411, 7, 79, 2, 2, 2411, 2444, 7, 268, 2, 2, 2412, 2413, 7, 275, 2, 2, 2413, 2414, 7, 96, 2, 2, 2414, 2444, 5, 1358, 680, 2, 2415, 2416, 7, 326, 2, 2, 2416, 2417, 7, 344, 2, 2, 2417, 2444, 5, 1330, 666, 2, 2418, 2419, 7, 326, 2, 2, 2419, 2444, 5, 118, 60, 2, 2420, 2421, 7, 306, 2, 2, 2421, 2444, 5, 118, 60, 2, 2422, 2423, 7, 305, 2, 2, 2423, 2424, 7, 221, 2, 2, 2424, 2444, 5, 116, 59, 2, 2425, 2426, 7, 195, 2, 2, 2426, 2427, 7, 407, 2, 2, 2427, 2428, 7, 244, 2, 2, 2428, 2444, 7, 320, 2, 2, 2429, 2430, 7, 188, 2, 2, 2430, 2431, 7, 407, 2, 2, 2431, 2432, 7, 244, 2, 2, 2432, 2444, 7, 320, 2, 2, 2433, 2434, 7, 211, 2, 2, 2434, 2435, 7, 407, 2, 2, 2435, 2436, 7, 244, 2, 2, 2436, 2444, 7, 320, 2, 2, 2437, 2438, 7, 262, 2, 2, 2438, 2439, 7, 211, 2, 2, 2439, 2440, 7, 407, 2, 2, 2440, 2441, 7, 244, 2, 2, 2441, 2444, 7, 320, 2, 2, 2442, 2444, 5, 346, 174, 2, 2443, 2191, 3, 2, 2, 2, 2443, 2193, 3, 2, 2, 2, 2443, 2198, 3, 2, 2, 2, 2443, 2201, 3, 2, 2, 2, 2443, 2207, 3, 2, 2, 2, 2443, 2212, 3, 2, 2, 2, 2443, 2219, 3, 2, 2, 2, 2443, 2226, 3, 2, 2, 2, 2443, 2232, 3, 2, 2, 2, 2443, 2240, 3, 2, 2, 2, 2443, 2247, 3, 2, 2, 2, 2443, 2254, 3, 2, 2, 2, 2443, 2260, 3, 2, 2, 2, 2443, 2266, 3, 2, 2, 2, 2443, 2273, 3, 2, 2, 2, 2443, 2283, 3, 2, 2, 2, 2443, 2288, 3, 2, 2, 2, 2443, 2294, 3, 2, 2, 2, 2443, 2302, 3, 2, 2, 2, 2443, 2309, 3, 2, 2, 2, 2443, 2314, 3, 2, 2, 2, 2443, 2323, 3, 2, 2, 2, 2443, 2328, 3, 2, 2, 2, 2443, 2330, 3, 2, 2, 2, 2443, 2335, 3, 2, 2, 2, 2443, 2338, 3, 2, 2, 2, 2443, 2345, 3, 2, 2, 2, 2443, 2350, 3, 2, 2, 2, 2443, 2353, 3, 2, 2, 2, 2443, 2356, 3, 2, 2, 2, 2443, 2359, 3, 2, 2, 2, 2443, 2361, 3, 2, 2, 2, 2443, 2363, 3, 2, 2, 2, 2443, 2366, 3, 2, 2, 2, 2443, 2370, 3, 2, 2, 2, 2443, 2374, 3, 2, 2, 2, 2443, 2377, 3, 2, 2, 2, 2443, 2380, 3, 2, 2, 2, 2443, 2383, 3, 2, 2, 2, 2443, 2386, 3, 2, 2, 2, 2443, 2389, 3, 2, 2, 2, 2443, 2392, 3, 2, 2, 2, 2443, 2396, 3, 2, 2, 2, 2443, 2400, 3, 2, 2, 2, 2443, 2403, 3, 2, 2, 2, 2443, 2405, 3, 2, 2, 2, 2443, 2408, 3, 2, 2, 2, 2443, 2410, 3, 2, 2, 2, 2443, 2412, 3, 2, 2, 2, 2443, 2415, 3, 2, 2, 2, 2443, 2418, 3, 2, 2, 2, 2443, 2420, 3, 2, 2, 2, 2443, 2422, 3, 2, 2, 2, 2443, 2425, 3, 2, 2, 2, 2443, 2429, 3, 2, 2, 2, 2443, 2433, 3, 2, 2, 2, 2443, 2437, 3, 2, 2, 2, 2443, 2442, 3, 2, 2, 2, 2444, 107, 3, 2, 2, 2, 2445, 2446, 7, 326, 2, 2, 2446, 2447, 7, 55, 2, 2, 2447, 2451, 5, 1154, 578, 2, 2448, 2449, 7, 193, 2, 2, 2449, 2451, 7, 55, 2, 2, 2450, 2445, 3, 2, 2, 2, 2450, 2448, 3, 2, 2, 2, 2451, 109, 3, 2, 2, 2, 2452, 2456, 7, 152, 2, 2, 2453, 2456, 7, 308, 2, 2, 2454, 2456, 3, 2, 2, 2, 2455, 2452, 3, 2, 2, 2, 2455, 2453, 3, 2, 2, 2, 2455, 2454, 3, 2, 2, 2, 2456, 111, 3, 2, 2, 2, 2457, 2458, 7, 45, 2, 2, 2458, 2461, 5, 526, 264, 2, 2459, 2461, 3, 2, 2, 2, 2460, 2457, 3, 2, 2, 2, 2460, 2459, 3, 2, 2, 2, 2461, 113, 3, 2, 2, 2, 2462, 2463, 7, 102, 2, 2, 2463, 2466, 5, 1154, 578, 2, 2464, 2466, 3, 2, 2, 2, 2465, 2462, 3, 2, 2, 2, 2465, 2464, 3, 2, 2, 2, 2466, 115, 3, 2, 2, 2, 2467, 2474, 7, 263, 2, 2, 2468, 2474, 7, 115, 2, 2, 2469, 2474, 7, 55, 2, 2, 2470, 2471, 7, 102, 2, 2, 2471, 2472, 7, 228, 2, 2, 2472, 2474, 5, 1330, 666, 2, 2473, 2467, 3, 2, 2, 2, 2473, 2468, 3, 2, 2, 2, 2473, 2469, 3, 2, 2, 2, 2473, 2470, 3, 2, 2, 2, 2474, 117, 3, 2, 2, 2, 2475, 2476, 7, 4, 2, 2, 2476, 2477, 5, 122, 62, 2, 2477, 2478, 7, 5, 2, 2, 2478, 119, 3, 2, 2, 2, 2479, 2480, 7, 107, 2, 2, 2480, 2483, 5, 118, 60, 2, 2481, 2483, 3, 2, 2, 2, 2482, 2479, 3, 2, 2, 2, 2482, 2481, 3, 2, 2, 2, 2483, 121, 3, 2, 2, 2, 2484, 2489, 5, 124, 63, 2, 2485, 2486, 7, 8, 2, 2, 2486, 2488, 5, 124, 63, 2, 2487, 2485, 3, 2, 2, 2, 2488, 2491, 3, 2, 2, 2, 2489, 2487, 3, 2, 2, 2, 2489, 2490, 3, 2, 2, 2, 2490, 123, 3, 2, 2, 2, 2491, 2489, 3, 2, 2, 2, 2492, 2501, 5, 1368, 685, 2, 2493, 2494, 7, 12, 2, 2, 2494, 2502, 5, 468, 235, 2, 2495, 2496, 7, 13, 2, 2, 2496, 2499, 5, 1368, 685, 2, 2497, 2498, 7, 12, 2, 2, 2498, 2500, 5, 468, 235, 2, 2499, 2497, 3, 2, 2, 2, 2499, 2500, 3, 2, 2, 2, 2500, 2502, 3, 2, 2, 2, 2501, 2493, 3, 2, 2, 2, 2501, 2495, 3, 2, 2, 2, 2501, 2502, 3, 2, 2, 2, 2502, 125, 3, 2, 2, 2, 2503, 2505, 5, 128, 65, 2, 2504, 2503, 3, 2, 2, 2, 2505, 2506, 3, 2, 2, 2, 2506, 2504, 3, 2, 2, 2, 2506, 2507, 3, 2, 2, 2, 2507, 127, 3, 2, 2, 2, 2508, 2512, 7, 307, 2, 2, 2509, 2510, 5, 18, 10, 2, 2510, 2511, 5, 294, 148, 2, 2511, 2513, 3, 2, 2, 2, 2512, 2509, 3, 2, 2, 2, 2512, 2513, 3, 2, 2, 2, 2513, 2521, 3, 2, 2, 2, 2514, 2518, 7, 326, 2, 2, 2515, 2519, 5, 290, 146, 2, 2516, 2517, 7, 431, 2, 2, 2517, 2519, 5, 200, 101, 2, 2518, 2515, 3, 2, 2, 2, 2518, 2516, 3, 2, 2, 2, 2519, 2521, 3, 2, 2, 2, 2520, 2508, 3, 2, 2, 2, 2520, 2514, 3, 2, 2, 2, 2521, 129, 3, 2, 2, 2, 2522, 2523, 7, 64, 2, 2, 2523, 2524, 7, 415, 2, 2, 2524, 2525, 7, 107, 2, 2, 2525, 2526, 7, 4, 2, 2, 2526, 2527, 5, 134, 68, 2, 2527, 2528, 7, 5, 2, 2, 2528, 2549, 3, 2, 2, 2, 2529, 2530, 7, 64, 2, 2, 2530, 2531, 7, 415, 2, 2, 2531, 2532, 7, 70, 2, 2, 2532, 2533, 7, 4, 2, 2, 2533, 2534, 5, 1270, 636, 2, 2534, 2535, 7, 5, 2, 2, 2535, 2549, 3, 2, 2, 2, 2536, 2537, 7, 64, 2, 2, 2537, 2538, 7, 415, 2, 2, 2538, 2539, 7, 66, 2, 2, 2539, 2540, 7, 4, 2, 2, 2540, 2541, 5, 1270, 636, 2, 2541, 2542, 7, 5, 2, 2, 2542, 2543, 7, 96, 2, 2, 2543, 2544, 7, 4, 2, 2, 2544, 2545, 5, 1270, 636, 2, 2545, 2546, 7, 5, 2, 2, 2546, 2549, 3, 2, 2, 2, 2547, 2549, 7, 55, 2, 2, 2548, 2522, 3, 2, 2, 2, 2548, 2529, 3, 2, 2, 2, 2548, 2536, 3, 2, 2, 2, 2548, 2547, 3, 2, 2, 2, 2549, 131, 3, 2, 2, 2, 2550, 2551, 5, 1366, 684, 2, 2551, 2552, 5, 1346, 674, 2, 2552, 133, 3, 2, 2, 2, 2553, 2558, 5, 132, 67, 2, 2554, 2555, 7, 8, 2, 2, 2555, 2557, 5, 132, 67, 2, 2556, 2554, 3, 2, 2, 2, 2557, 2560, 3, 2, 2, 2, 2558, 2556, 3, 2, 2, 2, 2558, 2559, 3, 2, 2, 2, 2559, 135, 3, 2, 2, 2, 2560, 2558, 3, 2, 2, 2, 2561, 2562, 7, 140, 2, 2, 2562, 2563, 7, 353, 2, 2, 2563, 2564, 5, 526, 264, 2, 2564, 2565, 5, 138, 70, 2, 2565, 137, 3, 2, 2, 2, 2566, 2571, 5, 140, 71, 2, 2567, 2568, 7, 8, 2, 2, 2568, 2570, 5, 140, 71, 2, 2569, 2567, 3, 2, 2, 2, 2570, 2573, 3, 2, 2, 2, 2571, 2569, 3, 2, 2, 2, 2571, 2572, 3, 2, 2, 2, 2572, 139, 3, 2, 2, 2, 2573, 2571, 3, 2, 2, 2, 2574, 2575, 7, 135, 2, 2, 2575, 2576, 7, 145, 2, 2, 2576, 2577, 5, 1094, 548, 2, 2577, 2578, 5, 110, 56, 2, 2578, 2598, 3, 2, 2, 2, 2579, 2580, 7, 193, 2, 2, 2580, 2583, 7, 145, 2, 2, 2581, 2582, 7, 222, 2, 2, 2582, 2584, 7, 389, 2, 2, 2583, 2581, 3, 2, 2, 2, 2583, 2584, 3, 2, 2, 2, 2584, 2585, 3, 2, 2, 2, 2585, 2586, 5, 1362, 682, 2, 2586, 2587, 5, 110, 56, 2, 2587, 2598, 3, 2, 2, 2, 2588, 2589, 7, 140, 2, 2, 2589, 2590, 7, 145, 2, 2, 2590, 2591, 5, 1362, 682, 2, 2591, 2592, 5, 728, 365, 2, 2592, 2593, 7, 353, 2, 2, 2593, 2594, 5, 1110, 556, 2, 2594, 2595, 5, 112, 57, 2, 2595, 2596, 5, 110, 56, 2, 2596, 2598, 3, 2, 2, 2, 2597, 2574, 3, 2, 2, 2, 2597, 2579, 3, 2, 2, 2, 2597, 2588, 3, 2, 2, 2, 2598, 141, 3, 2, 2, 2, 2599, 2602, 7, 159, 2, 2, 2600, 2603, 5, 948, 475, 2, 2601, 2603, 7, 32, 2, 2, 2602, 2600, 3, 2, 2, 2, 2602, 2601, 3, 2, 2, 2, 2603, 143, 3, 2, 2, 2, 2604, 2605, 7, 171, 2, 2, 2605, 2606, 5, 158, 80, 2, 2606, 2607, 5, 1326, 664, 2, 2607, 2608, 5, 216, 109, 2, 2608, 2609, 5, 146, 74, 2, 2609, 2610, 5, 148, 75, 2, 2610, 2611, 5, 150, 76, 2, 2611, 2612, 5, 160, 81, 2, 2612, 2613, 5, 18, 10, 2, 2613, 2614, 5, 152, 77, 2, 2614, 2615, 5, 1086, 544, 2, 2615, 2627, 3, 2, 2, 2, 2616, 2617, 7, 171, 2, 2, 2617, 2618, 7, 4, 2, 2, 2618, 2619, 5, 896, 449, 2, 2619, 2620, 7, 5, 2, 2, 2620, 2621, 7, 96, 2, 2, 2621, 2622, 5, 148, 75, 2, 2622, 2623, 5, 150, 76, 2, 2623, 2624, 5, 18, 10, 2, 2624, 2625, 5, 152, 77, 2, 2625, 2627, 3, 2, 2, 2, 2626, 2604, 3, 2, 2, 2, 2626, 2616, 3, 2, 2, 2, 2627, 145, 3, 2, 2, 2, 2628, 2629, 9, 12, 2, 2, 2629, 147, 3, 2, 2, 2, 2630, 2633, 7, 290, 2, 2, 2631, 2633, 3, 2, 2, 2, 2632, 2630, 3, 2, 2, 2, 2632, 2631, 3, 2, 2, 2, 2633, 149, 3, 2, 2, 2, 2634, 2638, 5, 1348, 675, 2, 2635, 2638, 7, 336, 2, 2, 2636, 2638, 7, 337, 2, 2, 2637, 2634, 3, 2, 2, 2, 2637, 2635, 3, 2, 2, 2, 2637, 2636, 3, 2, 2, 2, 2638, 151, 3, 2, 2, 2, 2639, 2645, 5, 154, 78, 2, 2640, 2641, 7, 4, 2, 2, 2641, 2642, 5, 164, 83, 2, 2642, 2643, 7, 5, 2, 2, 2643, 2645, 3, 2, 2, 2, 2644, 2639, 3, 2, 2, 2, 2644, 2640, 3, 2, 2, 2, 2645, 153, 3, 2, 2, 2, 2646, 2648, 5, 156, 79, 2, 2647, 2646, 3, 2, 2, 2, 2648, 2651, 3, 2, 2, 2, 2649, 2647, 3, 2, 2, 2, 2649, 2650, 3, 2, 2, 2, 2650, 155, 3, 2, 2, 2, 2651, 2649, 3, 2, 2, 2, 2652, 2688, 7, 109, 2, 2, 2653, 2688, 7, 114, 2, 2, 2654, 2655, 7, 185, 2, 2, 2655, 2656, 5, 836, 419, 2, 2656, 2657, 5, 1348, 675, 2, 2657, 2688, 3, 2, 2, 2, 2658, 2659, 7, 80, 2, 2, 2659, 2660, 5, 836, 419, 2, 2660, 2661, 5, 1348, 675, 2, 2661, 2688, 3, 2, 2, 2, 2662, 2688, 7, 173, 2, 2, 2663, 2688, 7, 218, 2, 2, 2664, 2665, 7, 291, 2, 2, 2665, 2666, 5, 836, 419, 2, 2666, 2667, 5, 1348, 675, 2, 2667, 2688, 3, 2, 2, 2, 2668, 2669, 7, 199, 2, 2, 2669, 2670, 5, 836, 419, 2, 2670, 2671, 5, 1348, 675, 2, 2671, 2688, 3, 2, 2, 2, 2672, 2673, 7, 211, 2, 2, 2673, 2674, 7, 291, 2, 2, 2674, 2688, 5, 218, 110, 2, 2675, 2676, 7, 211, 2, 2, 2676, 2677, 7, 291, 2, 2, 2677, 2688, 7, 11, 2, 2, 2678, 2679, 7, 211, 2, 2, 2679, 2680, 7, 79, 2, 2, 2680, 2681, 7, 80, 2, 2, 2681, 2688, 5, 218, 110, 2, 2682, 2683, 7, 211, 2, 2, 2683, 2684, 7, 80, 2, 2, 2684, 2688, 5, 218, 110, 2, 2685, 2686, 7, 196, 2, 2, 2686, 2688, 5, 1348, 675, 2, 2687, 2652, 3, 2, 2, 2, 2687, 2653, 3, 2, 2, 2, 2687, 2654, 3, 2, 2, 2, 2687, 2658, 3, 2, 2, 2, 2687, 2662, 3, 2, 2, 2, 2687, 2663, 3, 2, 2, 2, 2687, 2664, 3, 2, 2, 2, 2687, 2668, 3, 2, 2, 2, 2687, 2672, 3, 2, 2, 2, 2687, 2675, 3, 2, 2, 2, 2687, 2678, 3, 2, 2, 2, 2687, 2682, 3, 2, 2, 2, 2687, 2685, 3, 2, 2, 2, 2688, 157, 3, 2, 2, 2, 2689, 2692, 7, 109, 2, 2, 2690, 2692, 3, 2, 2, 2, 2691, 2689, 3, 2, 2, 2, 2691, 2690, 3, 2, 2, 2, 2692, 159, 3, 2, 2, 2, 2693, 2694, 5, 162, 82, 2, 2694, 2695, 7, 186, 2, 2, 2695, 2696, 5, 1348, 675, 2, 2696, 2699, 3, 2, 2, 2, 2697, 2699, 3, 2, 2, 2, 2698, 2693, 3, 2, 2, 2, 2698, 2697, 3, 2, 2, 2, 2699, 161, 3, 2, 2, 2, 2700, 2703, 7, 102, 2, 2, 2701, 2703, 3, 2, 2, 2, 2702, 2700, 3, 2, 2, 2, 2702, 2701, 3, 2, 2, 2, 2703, 163, 3, 2, 2, 2, 2704, 2709, 5, 166, 84, 2, 2705, 2706, 7, 8, 2, 2, 2706, 2708, 5, 166, 84, 2, 2707, 2705, 3, 2, 2, 2, 2708, 2711, 3, 2, 2, 2, 2709, 2707, 3, 2, 2, 2, 2709, 2710, 3, 2, 2, 2, 2710, 165, 3, 2, 2, 2, 2711, 2709, 3, 2, 2, 2, 2712, 2713, 5, 1368, 685, 2, 2713, 2714, 5, 168, 85, 2, 2714, 167, 3, 2, 2, 2, 2715, 2724, 5, 68, 35, 2, 2716, 2724, 5, 294, 148, 2, 2717, 2724, 7, 11, 2, 2, 2718, 2719, 7, 4, 2, 2, 2719, 2720, 5, 170, 86, 2, 2720, 2721, 7, 5, 2, 2, 2721, 2724, 3, 2, 2, 2, 2722, 2724, 3, 2, 2, 2, 2723, 2715, 3, 2, 2, 2, 2723, 2716, 3, 2, 2, 2, 2723, 2717, 3, 2, 2, 2, 2723, 2718, 3, 2, 2, 2, 2723, 2722, 3, 2, 2, 2, 2724, 169, 3, 2, 2, 2, 2725, 2730, 5, 172, 87, 2, 2726, 2727, 7, 8, 2, 2, 2727, 2729, 5, 172, 87, 2, 2728, 2726, 3, 2, 2, 2, 2729, 2732, 3, 2, 2, 2, 2730, 2728, 3, 2, 2, 2, 2730, 2731, 3, 2, 2, 2, 2731, 171, 3, 2, 2, 2, 2732, 2730, 3, 2, 2, 2, 2733, 2734, 5, 68, 35, 2, 2734, 173, 3, 2, 2, 2, 2735, 2736, 7, 48, 2, 2, 2736, 2737, 5, 176, 89, 2, 2737, 2741, 7, 94, 2, 2, 2738, 2739, 7, 222, 2, 2, 2739, 2740, 7, 79, 2, 2, 2740, 2742, 7, 389, 2, 2, 2741, 2738, 3, 2, 2, 2, 2741, 2742, 3, 2, 2, 2, 2742, 2743, 3, 2, 2, 2, 2743, 2774, 5, 1326, 664, 2, 2744, 2745, 7, 4, 2, 2, 2745, 2746, 5, 178, 90, 2, 2746, 2747, 7, 5, 2, 2, 2747, 2748, 5, 240, 121, 2, 2748, 2749, 5, 242, 122, 2, 2749, 2750, 5, 250, 126, 2, 2750, 2751, 5, 252, 127, 2, 2751, 2752, 5, 254, 128, 2, 2752, 2753, 5, 256, 129, 2, 2753, 2775, 3, 2, 2, 2, 2754, 2755, 7, 268, 2, 2, 2755, 2756, 5, 526, 264, 2, 2756, 2757, 5, 180, 91, 2, 2757, 2758, 5, 242, 122, 2, 2758, 2759, 5, 250, 126, 2, 2759, 2760, 5, 252, 127, 2, 2760, 2761, 5, 254, 128, 2, 2761, 2762, 5, 256, 129, 2, 2762, 2775, 3, 2, 2, 2, 2763, 2764, 7, 278, 2, 2, 2764, 2765, 7, 268, 2, 2, 2765, 2766, 5, 1326, 664, 2, 2766, 2767, 5, 180, 91, 2, 2767, 2768, 5, 130, 66, 2, 2768, 2769, 5, 242, 122, 2, 2769, 2770, 5, 250, 126, 2, 2770, 2771, 5, 252, 127, 2, 2771, 2772, 5, 254, 128, 2, 2772, 2773, 5, 256, 129, 2, 2773, 2775, 3, 2, 2, 2, 2774, 2744, 3, 2, 2, 2, 2774, 2754, 3, 2, 2, 2, 2774, 2763, 3, 2, 2, 2, 2775, 175, 3, 2, 2, 2, 2776, 2785, 7, 347, 2, 2, 2777, 2785, 7, 345, 2, 2, 2778, 2779, 7, 247, 2, 2, 2779, 2785, 9, 13, 2, 2, 2780, 2781, 7, 215, 2, 2, 2781, 2785, 9, 13, 2, 2, 2782, 2785, 7, 360, 2, 2, 2783, 2785, 3, 2, 2, 2, 2784, 2776, 3, 2, 2, 2, 2784, 2777, 3, 2, 2, 2, 2784, 2778, 3, 2, 2, 2, 2784, 2780, 3, 2, 2, 2, 2784, 2782, 3, 2, 2, 2, 2784, 2783, 3, 2, 2, 2, 2785, 177, 3, 2, 2, 2, 2786, 2789, 5, 182, 92, 2, 2787, 2789, 3, 2, 2, 2, 2788, 2786, 3, 2, 2, 2, 2788, 2787, 3, 2, 2, 2, 2789, 179, 3, 2, 2, 2, 2790, 2791, 7, 4, 2, 2, 2791, 2792, 5, 184, 93, 2, 2792, 2793, 7, 5, 2, 2, 2793, 2796, 3, 2, 2, 2, 2794, 2796, 3, 2, 2, 2, 2795, 2790, 3, 2, 2, 2, 2795, 2794, 3, 2, 2, 2, 2796, 181, 3, 2, 2, 2, 2797, 2802, 5, 186, 94, 2, 2798, 2799, 7, 8, 2, 2, 2799, 2801, 5, 186, 94, 2, 2800, 2798, 3, 2, 2, 2, 2801, 2804, 3, 2, 2, 2, 2802, 2800, 3, 2, 2, 2, 2802, 2803, 3, 2, 2, 2, 2803, 183, 3, 2, 2, 2, 2804, 2802, 3, 2, 2, 2, 2805, 2810, 5, 188, 95, 2, 2806, 2807, 7, 8, 2, 2, 2807, 2809, 5, 188, 95, 2, 2808, 2806, 3, 2, 2, 2, 2809, 2812, 3, 2, 2, 2, 2810, 2808, 3, 2, 2, 2, 2810, 2811, 3, 2, 2, 2, 2811, 185, 3, 2, 2, 2, 2812, 2810, 3, 2, 2, 2, 2813, 2817, 5, 190, 96, 2, 2814, 2817, 5, 204, 103, 2, 2815, 2817, 5, 210, 106, 2, 2816, 2813, 3, 2, 2, 2, 2816, 2814, 3, 2, 2, 2, 2816, 2815, 3, 2, 2, 2, 2817, 187, 3, 2, 2, 2, 2818, 2821, 5, 192, 97, 2, 2819, 2821, 5, 210, 106, 2, 2820, 2818, 3, 2, 2, 2, 2820, 2819, 3, 2, 2, 2, 2821, 189, 3, 2, 2, 2, 2822, 2823, 5, 1362, 682, 2, 2823, 2824, 5, 1110, 556, 2, 2824, 2825, 5, 342, 172, 2, 2825, 2826, 5, 194, 98, 2, 2826, 191, 3, 2, 2, 2, 2827, 2830, 5, 1362, 682, 2, 2828, 2829, 7, 107, 2, 2, 2829, 2831, 7, 273, 2, 2, 2830, 2828, 3, 2, 2, 2, 2830, 2831, 3, 2, 2, 2, 2831, 2832, 3, 2, 2, 2, 2832, 2833, 5, 194, 98, 2, 2833, 193, 3, 2, 2, 2, 2834, 2836, 5, 196, 99, 2, 2835, 2834, 3, 2, 2, 2, 2836, 2839, 3, 2, 2, 2, 2837, 2835, 3, 2, 2, 2, 2837, 2838, 3, 2, 2, 2, 2838, 195, 3, 2, 2, 2, 2839, 2837, 3, 2, 2, 2, 2840, 2841, 7, 47, 2, 2, 2841, 2842, 5, 1330, 666, 2, 2842, 2843, 5, 198, 100, 2, 2843, 2849, 3, 2, 2, 2, 2844, 2849, 5, 198, 100, 2, 2845, 2849, 5, 202, 102, 2, 2846, 2847, 7, 45, 2, 2, 2847, 2849, 5, 526, 264, 2, 2848, 2840, 3, 2, 2, 2, 2848, 2844, 3, 2, 2, 2, 2848, 2845, 3, 2, 2, 2, 2848, 2846, 3, 2, 2, 2, 2849, 197, 3, 2, 2, 2, 2850, 2851, 7, 79, 2, 2, 2851, 2889, 7, 80, 2, 2, 2852, 2889, 7, 80, 2, 2, 2853, 2854, 7, 100, 2, 2, 2854, 2855, 5, 666, 334, 2, 2855, 2856, 5, 258, 130, 2, 2856, 2889, 3, 2, 2, 2, 2857, 2858, 7, 87, 2, 2, 2858, 2859, 7, 238, 2, 2, 2859, 2860, 5, 666, 334, 2, 2860, 2861, 5, 258, 130, 2, 2861, 2889, 3, 2, 2, 2, 2862, 2863, 7, 44, 2, 2, 2863, 2864, 7, 4, 2, 2, 2864, 2865, 5, 1154, 578, 2, 2865, 2866, 7, 5, 2, 2, 2866, 2867, 5, 214, 108, 2, 2867, 2889, 3, 2, 2, 2, 2868, 2869, 7, 55, 2, 2, 2869, 2889, 5, 1194, 598, 2, 2870, 2871, 7, 431, 2, 2, 2871, 2872, 5, 200, 101, 2, 2872, 2880, 7, 38, 2, 2, 2873, 2874, 7, 221, 2, 2, 2874, 2881, 5, 286, 144, 2, 2875, 2876, 7, 4, 2, 2, 2876, 2877, 5, 1154, 578, 2, 2877, 2878, 7, 5, 2, 2, 2878, 2879, 7, 433, 2, 2, 2879, 2881, 3, 2, 2, 2, 2880, 2873, 3, 2, 2, 2, 2880, 2875, 3, 2, 2, 2, 2881, 2889, 3, 2, 2, 2, 2882, 2883, 7, 88, 2, 2, 2883, 2884, 5, 1326, 664, 2, 2884, 2885, 5, 216, 109, 2, 2885, 2886, 5, 224, 113, 2, 2886, 2887, 5, 232, 117, 2, 2887, 2889, 3, 2, 2, 2, 2888, 2850, 3, 2, 2, 2, 2888, 2852, 3, 2, 2, 2, 2888, 2853, 3, 2, 2, 2, 2888, 2857, 3, 2, 2, 2, 2888, 2862, 3, 2, 2, 2, 2888, 2868, 3, 2, 2, 2, 2888, 2870, 3, 2, 2, 2, 2888, 2882, 3, 2, 2, 2, 2889, 199, 3, 2, 2, 2, 2890, 2894, 7, 141, 2, 2, 2891, 2892, 7, 149, 2, 2, 2892, 2894, 7, 55, 2, 2, 2893, 2890, 3, 2, 2, 2, 2893, 2891, 3, 2, 2, 2, 2894, 201, 3, 2, 2, 2, 2895, 2901, 7, 56, 2, 2, 2896, 2897, 7, 79, 2, 2, 2897, 2901, 7, 56, 2, 2, 2898, 2899, 7, 71, 2, 2, 2899, 2901, 9, 10, 2, 2, 2900, 2895, 3, 2, 2, 2, 2900, 2896, 3, 2, 2, 2, 2900, 2898, 3, 2, 2, 2, 2901, 203, 3, 2, 2, 2, 2902, 2903, 7, 122, 2, 2, 2903, 2904, 5, 1326, 664, 2, 2904, 2905, 5, 206, 104, 2, 2905, 205, 3, 2, 2, 2, 2906, 2907, 9, 14, 2, 2, 2907, 2909, 5, 208, 105, 2, 2908, 2906, 3, 2, 2, 2, 2909, 2912, 3, 2, 2, 2, 2910, 2908, 3, 2, 2, 2, 2910, 2911, 3, 2, 2, 2, 2911, 207, 3, 2, 2, 2, 2912, 2910, 3, 2, 2, 2, 2913, 2914, 9, 15, 2, 2, 2914, 209, 3, 2, 2, 2, 2915, 2916, 7, 47, 2, 2, 2916, 2917, 5, 1330, 666, 2, 2917, 2918, 5, 212, 107, 2, 2918, 2921, 3, 2, 2, 2, 2919, 2921, 5, 212, 107, 2, 2920, 2915, 3, 2, 2, 2, 2920, 2919, 3, 2, 2, 2, 2921, 211, 3, 2, 2, 2, 2922, 2923, 7, 44, 2, 2, 2923, 2924, 7, 4, 2, 2, 2924, 2925, 5, 1154, 578, 2, 2925, 2926, 7, 5, 2, 2, 2926, 2927, 5, 442, 222, 2, 2927, 2981, 3, 2, 2, 2, 2928, 2940, 7, 100, 2, 2, 2929, 2930, 7, 4, 2, 2, 2930, 2931, 5, 218, 110, 2, 2931, 2932, 7, 5, 2, 2, 2932, 2933, 5, 222, 112, 2, 2933, 2934, 5, 666, 334, 2, 2934, 2935, 5, 258, 130, 2, 2935, 2936, 5, 442, 222, 2, 2936, 2941, 3, 2, 2, 2, 2937, 2938, 5, 260, 131, 2, 2938, 2939, 5, 442, 222, 2, 2939, 2941, 3, 2, 2, 2, 2940, 2929, 3, 2, 2, 2, 2940, 2937, 3, 2, 2, 2, 2941, 2981, 3, 2, 2, 2, 2942, 2943, 7, 87, 2, 2, 2943, 2955, 7, 238, 2, 2, 2944, 2945, 7, 4, 2, 2, 2945, 2946, 5, 218, 110, 2, 2946, 2947, 7, 5, 2, 2, 2947, 2948, 5, 222, 112, 2, 2948, 2949, 5, 666, 334, 2, 2949, 2950, 5, 258, 130, 2, 2950, 2951, 5, 442, 222, 2, 2951, 2956, 3, 2, 2, 2, 2952, 2953, 5, 260, 131, 2, 2953, 2954, 5, 442, 222, 2, 2954, 2956, 3, 2, 2, 2, 2955, 2944, 3, 2, 2, 2, 2955, 2952, 3, 2, 2, 2, 2956, 2981, 3, 2, 2, 2, 2957, 2958, 7, 201, 2, 2, 2958, 2959, 5, 598, 300, 2, 2959, 2960, 7, 4, 2, 2, 2960, 2961, 5, 226, 114, 2, 2961, 2962, 7, 5, 2, 2, 2962, 2963, 5, 222, 112, 2, 2963, 2964, 5, 666, 334, 2, 2964, 2965, 5, 258, 130, 2, 2965, 2966, 5, 230, 116, 2, 2966, 2967, 5, 442, 222, 2, 2967, 2981, 3, 2, 2, 2, 2968, 2969, 7, 65, 2, 2, 2969, 2970, 7, 238, 2, 2, 2970, 2971, 7, 4, 2, 2, 2971, 2972, 5, 218, 110, 2, 2972, 2973, 7, 5, 2, 2, 2973, 2974, 7, 88, 2, 2, 2974, 2975, 5, 1326, 664, 2, 2975, 2976, 5, 216, 109, 2, 2976, 2977, 5, 224, 113, 2, 2977, 2978, 5, 232, 117, 2, 2978, 2979, 5, 442, 222, 2, 2979, 2981, 3, 2, 2, 2, 2980, 2922, 3, 2, 2, 2, 2980, 2928, 3, 2, 2, 2, 2980, 2942, 3, 2, 2, 2, 2980, 2957, 3, 2, 2, 2, 2980, 2968, 3, 2, 2, 2, 2981, 213, 3, 2, 2, 2, 2982, 2983, 7, 262, 2, 2, 2983, 2986, 7, 230, 2, 2, 2984, 2986, 3, 2, 2, 2, 2985, 2982, 3, 2, 2, 2, 2985, 2984, 3, 2, 2, 2, 2986, 215, 3, 2, 2, 2, 2987, 2988, 7, 4, 2, 2, 2988, 2989, 5, 218, 110, 2, 2989, 2990, 7, 5, 2, 2, 2990, 2993, 3, 2, 2, 2, 2991, 2993, 3, 2, 2, 2, 2992, 2987, 3, 2, 2, 2, 2992, 2991, 3, 2, 2, 2, 2993, 217, 3, 2, 2, 2, 2994, 2999, 5, 220, 111, 2, 2995, 2996, 7, 8, 2, 2, 2996, 2998, 5, 220, 111, 2, 2997, 2995, 3, 2, 2, 2, 2998, 3001, 3, 2, 2, 2, 2999, 2997, 3, 2, 2, 2, 2999, 3000, 3, 2, 2, 2, 3000, 219, 3, 2, 2, 2, 3001, 2999, 3, 2, 2, 2, 3002, 3003, 5, 1362, 682, 2, 3003, 221, 3, 2, 2, 2, 3004, 3005, 7, 434, 2, 2, 3005, 3006, 7, 4, 2, 2, 3006, 3007, 5, 218, 110, 2, 3007, 3008, 7, 5, 2, 2, 3008, 3011, 3, 2, 2, 2, 3009, 3011, 3, 2, 2, 2, 3010, 3004, 3, 2, 2, 2, 3010, 3009, 3, 2, 2, 2, 3011, 223, 3, 2, 2, 2, 3012, 3013, 7, 251, 2, 2, 3013, 3016, 9, 16, 2, 2, 3014, 3016, 3, 2, 2, 2, 3015, 3012, 3, 2, 2, 2, 3015, 3014, 3, 2, 2, 2, 3016, 225, 3, 2, 2, 2, 3017, 3022, 5, 228, 115, 2, 3018, 3019, 7, 8, 2, 2, 3019, 3021, 5, 228, 115, 2, 3020, 3018, 3, 2, 2, 2, 3021, 3024, 3, 2, 2, 2, 3022, 3020, 3, 2, 2, 2, 3022, 3023, 3, 2, 2, 2, 3023, 227, 3, 2, 2, 2, 3024, 3022, 3, 2, 2, 2, 3025, 3026, 5, 604, 303, 2, 3026, 3033, 7, 107, 2, 2, 3027, 3034, 5, 686, 344, 2, 3028, 3029, 7, 271, 2, 2, 3029, 3030, 7, 4, 2, 2, 3030, 3031, 5, 686, 344, 2, 3031, 3032, 7, 5, 2, 2, 3032, 3034, 3, 2, 2, 2, 3033, 3027, 3, 2, 2, 2, 3033, 3028, 3, 2, 2, 2, 3034, 229, 3, 2, 2, 2, 3035, 3036, 7, 105, 2, 2, 3036, 3037, 7, 4, 2, 2, 3037, 3038, 5, 1154, 578, 2, 3038, 3039, 7, 5, 2, 2, 3039, 3042, 3, 2, 2, 2, 3040, 3042, 3, 2, 2, 2, 3041, 3035, 3, 2, 2, 2, 3041, 3040, 3, 2, 2, 2, 3042, 231, 3, 2, 2, 2, 3043, 3053, 5, 234, 118, 2, 3044, 3053, 5, 236, 119, 2, 3045, 3046, 5, 234, 118, 2, 3046, 3047, 5, 236, 119, 2, 3047, 3053, 3, 2, 2, 2, 3048, 3049, 5, 236, 119, 2, 3049, 3050, 5, 234, 118, 2, 3050, 3053, 3, 2, 2, 2, 3051, 3053, 3, 2, 2, 2, 3052, 3043, 3, 2, 2, 2, 3052, 3044, 3, 2, 2, 2, 3052, 3045, 3, 2, 2, 2, 3052, 3048, 3, 2, 2, 2, 3052, 3051, 3, 2, 2, 2, 3053, 233, 3, 2, 2, 2, 3054, 3055, 7, 82, 2, 2, 3055, 3056, 7, 362, 2, 2, 3056, 3057, 5, 238, 120, 2, 3057, 235, 3, 2, 2, 2, 3058, 3059, 7, 82, 2, 2, 3059, 3060, 7, 184, 2, 2, 3060, 3061, 5, 238, 120, 2, 3061, 237, 3, 2, 2, 2, 3062, 3063, 7, 262, 2, 2, 3063, 3069, 7, 134, 2, 2, 3064, 3069, 7, 308, 2, 2, 3065, 3069, 7, 152, 2, 2, 3066, 3067, 7, 326, 2, 2, 3067, 3069, 9, 17, 2, 2, 3068, 3062, 3, 2, 2, 2, 3068, 3064, 3, 2, 2, 2, 3068, 3065, 3, 2, 2, 2, 3068, 3066, 3, 2, 2, 2, 3069, 239, 3, 2, 2, 2, 3070, 3071, 7, 231, 2, 2, 3071, 3072, 7, 4, 2, 2, 3072, 3073, 5, 1324, 663, 2, 3073, 3074, 7, 5, 2, 2, 3074, 3077, 3, 2, 2, 2, 3075, 3077, 3, 2, 2, 2, 3076, 3070, 3, 2, 2, 2, 3076, 3075, 3, 2, 2, 2, 3077, 241, 3, 2, 2, 2, 3078, 3081, 5, 244, 123, 2, 3079, 3081, 3, 2, 2, 2, 3080, 3078, 3, 2, 2, 2, 3080, 3079, 3, 2, 2, 2, 3081, 243, 3, 2, 2, 2, 3082, 3083, 7, 278, 2, 2, 3083, 3084, 7, 149, 2, 2, 3084, 3085, 5, 1362, 682, 2, 3085, 3086, 7, 4, 2, 2, 3086, 3087, 5, 246, 124, 2, 3087, 3088, 7, 5, 2, 2, 3088, 245, 3, 2, 2, 2, 3089, 3094, 5, 248, 125, 2, 3090, 3091, 7, 8, 2, 2, 3091, 3093, 5, 248, 125, 2, 3092, 3090, 3, 2, 2, 2, 3093, 3096, 3, 2, 2, 2, 3094, 3092, 3, 2, 2, 2, 3094, 3095, 3, 2, 2, 2, 3095, 247, 3, 2, 2, 2, 3096, 3094, 3, 2, 2, 2, 3097, 3098, 5, 1362, 682, 2, 3098, 3099, 5, 610, 306, 2, 3099, 3100, 5, 612, 307, 2, 3100, 3112, 3, 2, 2, 2, 3101, 3102, 5, 1204, 603, 2, 3102, 3103, 5, 610, 306, 2, 3103, 3104, 5, 612, 307, 2, 3104, 3112, 3, 2, 2, 2, 3105, 3106, 7, 4, 2, 2, 3106, 3107, 5, 1154, 578, 2, 3107, 3108, 7, 5, 2, 2, 3108, 3109, 5, 610, 306, 2, 3109, 3110, 5, 612, 307, 2, 3110, 3112, 3, 2, 2, 2, 3111, 3097, 3, 2, 2, 2, 3111, 3101, 3, 2, 2, 2, 3111, 3105, 3, 2, 2, 2, 3112, 249, 3, 2, 2, 2, 3113, 3114, 7, 102, 2, 2, 3114, 3117, 5, 1330, 666, 2, 3115, 3117, 3, 2, 2, 2, 3116, 3113, 3, 2, 2, 2, 3116, 3115, 3, 2, 2, 2, 3117, 251, 3, 2, 2, 2, 3118, 3119, 7, 107, 2, 2, 3119, 3124, 5, 118, 60, 2, 3120, 3121, 7, 372, 2, 2, 3121, 3124, 7, 270, 2, 2, 3122, 3124, 3, 2, 2, 2, 3123, 3118, 3, 2, 2, 2, 3123, 3120, 3, 2, 2, 2, 3123, 3122, 3, 2, 2, 2, 3124, 253, 3, 2, 2, 2, 3125, 3126, 7, 82, 2, 2, 3126, 3132, 7, 163, 2, 2, 3127, 3133, 7, 193, 2, 2, 3128, 3129, 7, 184, 2, 2, 3129, 3133, 7, 313, 2, 2, 3130, 3131, 7, 285, 2, 2, 3131, 3133, 7, 313, 2, 2, 3132, 3127, 3, 2, 2, 2, 3132, 3128, 3, 2, 2, 2, 3132, 3130, 3, 2, 2, 2, 3133, 3136, 3, 2, 2, 2, 3134, 3136, 3, 2, 2, 2, 3135, 3125, 3, 2, 2, 2, 3135, 3134, 3, 2, 2, 2, 3136, 255, 3, 2, 2, 2, 3137, 3138, 7, 344, 2, 2, 3138, 3141, 5, 1330, 666, 2, 3139, 3141, 3, 2, 2, 2, 3140, 3137, 3, 2, 2, 2, 3140, 3139, 3, 2, 2, 2, 3141, 257, 3, 2, 2, 2, 3142, 3143, 7, 102, 2, 2, 3143, 3144, 7, 228, 2, 2, 3144, 3145, 7, 344, 2, 2, 3145, 3148, 5, 1330, 666, 2, 3146, 3148, 3, 2, 2, 2, 3147, 3142, 3, 2, 2, 2, 3147, 3146, 3, 2, 2, 2, 3148, 259, 3, 2, 2, 2, 3149, 3150, 7, 102, 2, 2, 3150, 3151, 7, 228, 2, 2, 3151, 3152, 5, 1330, 666, 2, 3152, 261, 3, 2, 2, 2, 3153, 3154, 7, 48, 2, 2, 3154, 3158, 7, 335, 2, 2, 3155, 3156, 7, 222, 2, 2, 3156, 3157, 7, 79, 2, 2, 3157, 3159, 7, 389, 2, 2, 3158, 3155, 3, 2, 2, 2, 3158, 3159, 3, 2, 2, 2, 3159, 3160, 3, 2, 2, 2, 3160, 3161, 5, 526, 264, 2, 3161, 3162, 5, 872, 437, 2, 3162, 3163, 7, 82, 2, 2, 3163, 3164, 5, 1270, 636, 2, 3164, 3165, 7, 66, 2, 2, 3165, 3166, 5, 1052, 527, 2, 3166, 263, 3, 2, 2, 2, 3167, 3168, 7, 140, 2, 2, 3168, 3171, 7, 335, 2, 2, 3169, 3170, 7, 222, 2, 2, 3170, 3172, 7, 389, 2, 2, 3171, 3169, 3, 2, 2, 2, 3171, 3172, 3, 2, 2, 2, 3172, 3173, 3, 2, 2, 2, 3173, 3174, 5, 526, 264, 2, 3174, 3175, 7, 326, 2, 2, 3175, 3176, 7, 335, 2, 2, 3176, 3177, 5, 1354, 678, 2, 3177, 265, 3, 2, 2, 2, 3178, 3179, 7, 48, 2, 2, 3179, 3180, 5, 176, 89, 2, 3180, 3184, 7, 94, 2, 2, 3181, 3182, 7, 222, 2, 2, 3182, 3183, 7, 79, 2, 2, 3183, 3185, 7, 389, 2, 2, 3184, 3181, 3, 2, 2, 2, 3184, 3185, 3, 2, 2, 2, 3185, 3186, 3, 2, 2, 2, 3186, 3187, 5, 268, 135, 2, 3187, 3188, 7, 38, 2, 2, 3188, 3189, 5, 954, 478, 2, 3189, 3190, 5, 270, 136, 2, 3190, 267, 3, 2, 2, 2, 3191, 3192, 5, 1326, 664, 2, 3192, 3193, 5, 216, 109, 2, 3193, 3194, 5, 250, 126, 2, 3194, 3195, 5, 252, 127, 2, 3195, 3196, 5, 254, 128, 2, 3196, 3197, 5, 256, 129, 2, 3197, 269, 3, 2, 2, 2, 3198, 3202, 7, 107, 2, 2, 3199, 3203, 7, 176, 2, 2, 3200, 3201, 7, 262, 2, 2, 3201, 3203, 7, 176, 2, 2, 3202, 3199, 3, 2, 2, 2, 3202, 3200, 3, 2, 2, 2, 3203, 3206, 3, 2, 2, 2, 3204, 3206, 3, 2, 2, 2, 3205, 3198, 3, 2, 2, 2, 3205, 3204, 3, 2, 2, 2, 3206, 271, 3, 2, 2, 2, 3207, 3208, 7, 48, 2, 2, 3208, 3209, 5, 276, 139, 2, 3209, 3210, 7, 252, 2, 2, 3210, 3214, 7, 369, 2, 2, 3211, 3212, 7, 222, 2, 2, 3212, 3213, 7, 79, 2, 2, 3213, 3215, 7, 389, 2, 2, 3214, 3211, 3, 2, 2, 2, 3214, 3215, 3, 2, 2, 2, 3215, 3216, 3, 2, 2, 2, 3216, 3217, 5, 274, 138, 2, 3217, 3218, 7, 38, 2, 2, 3218, 3219, 5, 954, 478, 2, 3219, 3220, 5, 270, 136, 2, 3220, 273, 3, 2, 2, 2, 3221, 3222, 5, 1326, 664, 2, 3222, 3223, 5, 216, 109, 2, 3223, 3224, 5, 250, 126, 2, 3224, 3225, 5, 120, 61, 2, 3225, 3226, 5, 256, 129, 2, 3226, 275, 3, 2, 2, 2, 3227, 3230, 7, 360, 2, 2, 3228, 3230, 3, 2, 2, 2, 3229, 3227, 3, 2, 2, 2, 3229, 3228, 3, 2, 2, 2, 3230, 277, 3, 2, 2, 2, 3231, 3232, 7, 298, 2, 2, 3232, 3233, 7, 252, 2, 2, 3233, 3234, 7, 369, 2, 2, 3234, 3235, 5, 594, 298, 2, 3235, 3236, 5, 1326, 664, 2, 3236, 3237, 5, 270, 136, 2, 3237, 279, 3, 2, 2, 2, 3238, 3239, 7, 48, 2, 2, 3239, 3240, 5, 176, 89, 2, 3240, 3244, 7, 321, 2, 2, 3241, 3242, 7, 222, 2, 2, 3242, 3243, 7, 79, 2, 2, 3243, 3245, 7, 389, 2, 2, 3244, 3241, 3, 2, 2, 2, 3244, 3245, 3, 2, 2, 2, 3245, 3246, 3, 2, 2, 2, 3246, 3247, 5, 1326, 664, 2, 3247, 3248, 5, 284, 143, 2, 3248, 281, 3, 2, 2, 2, 3249, 3250, 7, 140, 2, 2, 3250, 3253, 7, 321, 2, 2, 3251, 3252, 7, 222, 2, 2, 3252, 3254, 7, 389, 2, 2, 3253, 3251, 3, 2, 2, 2, 3253, 3254, 3, 2, 2, 2, 3254, 3255, 3, 2, 2, 2, 3255, 3256, 5, 1326, 664, 2, 3256, 3257, 5, 288, 145, 2, 3257, 283, 3, 2, 2, 2, 3258, 3261, 5, 288, 145, 2, 3259, 3261, 3, 2, 2, 2, 3260, 3258, 3, 2, 2, 2, 3260, 3259, 3, 2, 2, 2, 3261, 285, 3, 2, 2, 2, 3262, 3263, 7, 4, 2, 2, 3263, 3264, 5, 288, 145, 2, 3264, 3265, 7, 5, 2, 2, 3265, 3268, 3, 2, 2, 2, 3266, 3268, 3, 2, 2, 2, 3267, 3262, 3, 2, 2, 2, 3267, 3266, 3, 2, 2, 2, 3268, 287, 3, 2, 2, 2, 3269, 3271, 5, 290, 146, 2, 3270, 3269, 3, 2, 2, 2, 3271, 3272, 3, 2, 2, 2, 3272, 3270, 3, 2, 2, 2, 3272, 3273, 3, 2, 2, 2, 3273, 289, 3, 2, 2, 2, 3274, 3275, 7, 38, 2, 2, 3275, 3305, 5, 1114, 558, 2, 3276, 3277, 7, 150, 2, 2, 3277, 3305, 5, 294, 148, 2, 3278, 3305, 7, 175, 2, 2, 3279, 3280, 7, 227, 2, 2, 3280, 3281, 5, 292, 147, 2, 3281, 3282, 5, 294, 148, 2, 3282, 3305, 3, 2, 2, 2, 3283, 3284, 7, 253, 2, 2, 3284, 3305, 5, 294, 148, 2, 3285, 3286, 7, 255, 2, 2, 3286, 3305, 5, 294, 148, 2, 3287, 3288, 7, 262, 2, 2, 3288, 3305, 9, 18, 2, 2, 3289, 3290, 7, 274, 2, 2, 3290, 3291, 7, 149, 2, 2, 3291, 3305, 5, 526, 264, 2, 3292, 3293, 7, 321, 2, 2, 3293, 3294, 7, 259, 2, 2, 3294, 3305, 5, 526, 264, 2, 3295, 3296, 7, 333, 2, 2, 3296, 3297, 5, 18, 10, 2, 3297, 3298, 5, 294, 148, 2, 3298, 3305, 3, 2, 2, 2, 3299, 3300, 7, 307, 2, 2, 3300, 3302, 5, 18, 10, 2, 3301, 3303, 5, 294, 148, 2, 3302, 3301, 3, 2, 2, 2, 3302, 3303, 3, 2, 2, 2, 3303, 3305, 3, 2, 2, 2, 3304, 3274, 3, 2, 2, 2, 3304, 3276, 3, 2, 2, 2, 3304, 3278, 3, 2, 2, 2, 3304, 3279, 3, 2, 2, 2, 3304, 3283, 3, 2, 2, 2, 3304, 3285, 3, 2, 2, 2, 3304, 3287, 3, 2, 2, 2, 3304, 3289, 3, 2, 2, 2, 3304, 3292, 3, 2, 2, 2, 3304, 3295, 3, 2, 2, 2, 3304, 3299, 3, 2, 2, 2, 3305, 291, 3, 2, 2, 2, 3306, 3309, 7, 149, 2, 2, 3307, 3309, 3, 2, 2, 2, 3308, 3306, 3, 2, 2, 2, 3308, 3307, 3, 2, 2, 2, 3309, 293, 3, 2, 2, 2, 3310, 3317, 5, 1344, 673, 2, 3311, 3312, 7, 14, 2, 2, 3312, 3317, 5, 1344, 673, 2, 3313, 3314, 7, 15, 2, 2, 3314, 3317, 5, 1344, 673, 2, 3315, 3317, 5, 1354, 678, 2, 3316, 3310, 3, 2, 2, 2, 3316, 3311, 3, 2, 2, 2, 3316, 3313, 3, 2, 2, 2, 3316, 3315, 3, 2, 2, 2, 3317, 295, 3, 2, 2, 2, 3318, 3323, 5, 294, 148, 2, 3319, 3320, 7, 8, 2, 2, 3320, 3322, 5, 294, 148, 2, 3321, 3319, 3, 2, 2, 2, 3322, 3325, 3, 2, 2, 2, 3323, 3321, 3, 2, 2, 2, 3323, 3324, 3, 2, 2, 2, 3324, 297, 3, 2, 2, 2, 3325, 3323, 3, 2, 2, 2, 3326, 3327, 7, 48, 2, 2, 3327, 3328, 5, 620, 311, 2, 3328, 3329, 5, 300, 151, 2, 3329, 3330, 5, 310, 156, 2, 3330, 3331, 7, 240, 2, 2, 3331, 3337, 5, 1330, 666, 2, 3332, 3333, 7, 217, 2, 2, 3333, 3334, 5, 302, 152, 2, 3334, 3335, 5, 304, 153, 2, 3335, 3336, 5, 308, 155, 2, 3336, 3338, 3, 2, 2, 2, 3337, 3332, 3, 2, 2, 2, 3337, 3338, 3, 2, 2, 2, 3338, 299, 3, 2, 2, 2, 3339, 3342, 7, 352, 2, 2, 3340, 3342, 3, 2, 2, 2, 3341, 3339, 3, 2, 2, 2, 3341, 3340, 3, 2, 2, 2, 3342, 301, 3, 2, 2, 2, 3343, 3345, 5, 1330, 666, 2, 3344, 3346, 5, 528, 265, 2, 3345, 3344, 3, 2, 2, 2, 3345, 3346, 3, 2, 2, 2, 3346, 303, 3, 2, 2, 2, 3347, 3348, 7, 232, 2, 2, 3348, 3351, 5, 302, 152, 2, 3349, 3351, 3, 2, 2, 2, 3350, 3347, 3, 2, 2, 2, 3350, 3349, 3, 2, 2, 2, 3351, 305, 3, 2, 2, 2, 3352, 3353, 7, 366, 2, 2, 3353, 3357, 5, 302, 152, 2, 3354, 3355, 7, 262, 2, 2, 3355, 3357, 7, 366, 2, 2, 3356, 3352, 3, 2, 2, 2, 3356, 3354, 3, 2, 2, 2, 3357, 307, 3, 2, 2, 2, 3358, 3361, 5, 306, 154, 2, 3359, 3361, 3, 2, 2, 2, 3360, 3358, 3, 2, 2, 2, 3360, 3359, 3, 2, 2, 2, 3361, 309, 3, 2, 2, 2, 3362, 3365, 7, 288, 2, 2, 3363, 3365, 3, 2, 2, 2, 3364, 3362, 3, 2, 2, 2, 3364, 3363, 3, 2, 2, 2, 3365, 311, 3, 2, 2, 2, 3366, 3367, 7, 48, 2, 2, 3367, 3368, 7, 344, 2, 2, 3368, 3369, 5, 1330, 666, 2, 3369, 3370, 5, 314, 158, 2, 3370, 3371, 7, 248, 2, 2, 3371, 3372, 5, 1348, 675, 2, 3372, 3373, 5, 120, 61, 2, 3373, 313, 3, 2, 2, 2, 3374, 3375, 7, 275, 2, 2, 3375, 3378, 5, 1358, 680, 2, 3376, 3378, 3, 2, 2, 2, 3377, 3374, 3, 2, 2, 2, 3377, 3376, 3, 2, 2, 2, 3378, 315, 3, 2, 2, 2, 3379, 3380, 7, 193, 2, 2, 3380, 3383, 7, 344, 2, 2, 3381, 3382, 7, 222, 2, 2, 3382, 3384, 7, 389, 2, 2, 3383, 3381, 3, 2, 2, 2, 3383, 3384, 3, 2, 2, 2, 3384, 3385, 3, 2, 2, 2, 3385, 3386, 5, 1330, 666, 2, 3386, 317, 3, 2, 2, 2, 3387, 3388, 7, 48, 2, 2, 3388, 3392, 7, 206, 2, 2, 3389, 3390, 7, 222, 2, 2, 3390, 3391, 7, 79, 2, 2, 3391, 3393, 7, 389, 2, 2, 3392, 3389, 3, 2, 2, 2, 3392, 3393, 3, 2, 2, 2, 3393, 3394, 3, 2, 2, 2, 3394, 3395, 5, 1330, 666, 2, 3395, 3396, 5, 18, 10, 2, 3396, 3397, 5, 320, 161, 2, 3397, 319, 3, 2, 2, 2, 3398, 3400, 5, 322, 162, 2, 3399, 3398, 3, 2, 2, 2, 3400, 3403, 3, 2, 2, 2, 3401, 3399, 3, 2, 2, 2, 3401, 3402, 3, 2, 2, 2, 3402, 321, 3, 2, 2, 2, 3403, 3401, 3, 2, 2, 2, 3404, 3405, 7, 316, 2, 2, 3405, 3412, 5, 1330, 666, 2, 3406, 3407, 7, 368, 2, 2, 3407, 3412, 5, 74, 38, 2, 3408, 3409, 7, 66, 2, 2, 3409, 3412, 5, 74, 38, 2, 3410, 3412, 7, 152, 2, 2, 3411, 3404, 3, 2, 2, 2, 3411, 3406, 3, 2, 2, 2, 3411, 3408, 3, 2, 2, 2, 3411, 3410, 3, 2, 2, 2, 3412, 323, 3, 2, 2, 2, 3413, 3414, 7, 140, 2, 2, 3414, 3415, 7, 206, 2, 2, 3415, 3416, 5, 1330, 666, 2, 3416, 3417, 7, 362, 2, 2, 3417, 3418, 5, 326, 164, 2, 3418, 325, 3, 2, 2, 2, 3419, 3421, 5, 328, 165, 2, 3420, 3419, 3, 2, 2, 2, 3421, 3424, 3, 2, 2, 2, 3422, 3420, 3, 2, 2, 2, 3422, 3423, 3, 2, 2, 2, 3423, 327, 3, 2, 2, 2, 3424, 3422, 3, 2, 2, 2, 3425, 3426, 7, 96, 2, 2, 3426, 3427, 5, 74, 38, 2, 3427, 329, 3, 2, 2, 2, 3428, 3429, 7, 140, 2, 2, 3429, 3430, 7, 206, 2, 2, 3430, 3431, 5, 1330, 666, 2, 3431, 3432, 5, 42, 22, 2, 3432, 3433, 5, 518, 260, 2, 3433, 3434, 5, 1330, 666, 2, 3434, 3533, 3, 2, 2, 2, 3435, 3436, 7, 140, 2, 2, 3436, 3437, 7, 206, 2, 2, 3437, 3438, 5, 1330, 666, 2, 3438, 3439, 5, 42, 22, 2, 3439, 3440, 5, 516, 259, 2, 3440, 3441, 5, 526, 264, 2, 3441, 3533, 3, 2, 2, 2, 3442, 3443, 7, 140, 2, 2, 3443, 3444, 7, 206, 2, 2, 3444, 3445, 5, 1330, 666, 2, 3445, 3446, 5, 42, 22, 2, 3446, 3447, 7, 138, 2, 2, 3447, 3448, 5, 652, 327, 2, 3448, 3533, 3, 2, 2, 2, 3449, 3450, 7, 140, 2, 2, 3450, 3451, 7, 206, 2, 2, 3451, 3452, 5, 1330, 666, 2, 3452, 3453, 5, 42, 22, 2, 3453, 3454, 7, 43, 2, 2, 3454, 3455, 7, 4, 2, 2, 3455, 3456, 5, 1110, 556, 2, 3456, 3457, 7, 38, 2, 2, 3457, 3458, 5, 1110, 556, 2, 3458, 3459, 7, 5, 2, 2, 3459, 3533, 3, 2, 2, 2, 3460, 3461, 7, 140, 2, 2, 3461, 3462, 7, 206, 2, 2, 3462, 3463, 5, 1330, 666, 2, 3463, 3464, 5, 42, 22, 2, 3464, 3465, 7, 191, 2, 2, 3465, 3466, 5, 1110, 556, 2, 3466, 3533, 3, 2, 2, 2, 3467, 3468, 7, 140, 2, 2, 3468, 3469, 7, 206, 2, 2, 3469, 3470, 5, 1330, 666, 2, 3470, 3471, 5, 42, 22, 2, 3471, 3472, 7, 213, 2, 2, 3472, 3473, 5, 628, 315, 2, 3473, 3533, 3, 2, 2, 2, 3474, 3475, 7, 140, 2, 2, 3475, 3476, 7, 206, 2, 2, 3476, 3477, 5, 1330, 666, 2, 3477, 3478, 5, 42, 22, 2, 3478, 3479, 7, 271, 2, 2, 3479, 3480, 5, 690, 346, 2, 3480, 3533, 3, 2, 2, 2, 3481, 3482, 7, 140, 2, 2, 3482, 3483, 7, 206, 2, 2, 3483, 3484, 5, 1330, 666, 2, 3484, 3485, 5, 42, 22, 2, 3485, 3486, 7, 271, 2, 2, 3486, 3487, 7, 158, 2, 2, 3487, 3488, 5, 526, 264, 2, 3488, 3489, 7, 102, 2, 2, 3489, 3490, 5, 1330, 666, 2, 3490, 3533, 3, 2, 2, 2, 3491, 3492, 7, 140, 2, 2, 3492, 3493, 7, 206, 2, 2, 3493, 3494, 5, 1330, 666, 2, 3494, 3495, 5, 42, 22, 2, 3495, 3496, 7, 271, 2, 2, 3496, 3497, 7, 208, 2, 2, 3497, 3498, 5, 526, 264, 2, 3498, 3499, 7, 102, 2, 2, 3499, 3500, 5, 1330, 666, 2, 3500, 3533, 3, 2, 2, 2, 3501, 3502, 7, 140, 2, 2, 3502, 3503, 7, 206, 2, 2, 3503, 3504, 5, 1330, 666, 2, 3504, 3505, 5, 42, 22, 2, 3505, 3506, 7, 289, 2, 2, 3506, 3507, 5, 628, 315, 2, 3507, 3533, 3, 2, 2, 2, 3508, 3509, 7, 140, 2, 2, 3509, 3510, 7, 206, 2, 2, 3510, 3511, 5, 1330, 666, 2, 3511, 3512, 5, 42, 22, 2, 3512, 3513, 7, 435, 2, 2, 3513, 3514, 5, 628, 315, 2, 3514, 3533, 3, 2, 2, 2, 3515, 3516, 7, 140, 2, 2, 3516, 3517, 7, 206, 2, 2, 3517, 3518, 5, 1330, 666, 2, 3518, 3519, 5, 42, 22, 2, 3519, 3520, 7, 436, 2, 2, 3520, 3521, 7, 64, 2, 2, 3521, 3522, 5, 1110, 556, 2, 3522, 3523, 7, 240, 2, 2, 3523, 3524, 5, 1330, 666, 2, 3524, 3533, 3, 2, 2, 2, 3525, 3526, 7, 140, 2, 2, 3526, 3527, 7, 206, 2, 2, 3527, 3528, 5, 1330, 666, 2, 3528, 3529, 5, 42, 22, 2, 3529, 3530, 7, 353, 2, 2, 3530, 3531, 5, 1110, 556, 2, 3531, 3533, 3, 2, 2, 2, 3532, 3428, 3, 2, 2, 2, 3532, 3435, 3, 2, 2, 2, 3532, 3442, 3, 2, 2, 2, 3532, 3449, 3, 2, 2, 2, 3532, 3460, 3, 2, 2, 2, 3532, 3467, 3, 2, 2, 2, 3532, 3474, 3, 2, 2, 2, 3532, 3481, 3, 2, 2, 2, 3532, 3491, 3, 2, 2, 2, 3532, 3501, 3, 2, 2, 2, 3532, 3508, 3, 2, 2, 2, 3532, 3515, 3, 2, 2, 2, 3532, 3525, 3, 2, 2, 2, 3533, 331, 3, 2, 2, 2, 3534, 3535, 7, 48, 2, 2, 3535, 3536, 7, 65, 2, 2, 3536, 3537, 7, 176, 2, 2, 3537, 3538, 7, 374, 2, 2, 3538, 3539, 5, 1330, 666, 2, 3539, 3540, 5, 338, 170, 2, 3540, 3541, 5, 342, 172, 2, 3541, 333, 3, 2, 2, 2, 3542, 3543, 7, 217, 2, 2, 3543, 3551, 5, 302, 152, 2, 3544, 3545, 7, 262, 2, 2, 3545, 3551, 7, 217, 2, 2, 3546, 3547, 7, 366, 2, 2, 3547, 3551, 5, 302, 152, 2, 3548, 3549, 7, 262, 2, 2, 3549, 3551, 7, 366, 2, 2, 3550, 3542, 3, 2, 2, 2, 3550, 3544, 3, 2, 2, 2, 3550, 3546, 3, 2, 2, 2, 3550, 3548, 3, 2, 2, 2, 3551, 335, 3, 2, 2, 2, 3552, 3554, 5, 334, 168, 2, 3553, 3552, 3, 2, 2, 2, 3554, 3555, 3, 2, 2, 2, 3555, 3553, 3, 2, 2, 2, 3555, 3556, 3, 2, 2, 2, 3556, 337, 3, 2, 2, 2, 3557, 3560, 5, 336, 169, 2, 3558, 3560, 3, 2, 2, 2, 3559, 3557, 3, 2, 2, 2, 3559, 3558, 3, 2, 2, 2, 3560, 339, 3, 2, 2, 2, 3561, 3562, 7, 140, 2, 2, 3562, 3563, 7, 65, 2, 2, 3563, 3564, 7, 176, 2, 2, 3564, 3565, 7, 374, 2, 2, 3565, 3566, 5, 1330, 666, 2, 3566, 3567, 5, 338, 170, 2, 3567, 3568, 5, 346, 174, 2, 3568, 3577, 3, 2, 2, 2, 3569, 3570, 7, 140, 2, 2, 3570, 3571, 7, 65, 2, 2, 3571, 3572, 7, 176, 2, 2, 3572, 3573, 7, 374, 2, 2, 3573, 3574, 5, 1330, 666, 2, 3574, 3575, 5, 336, 169, 2, 3575, 3577, 3, 2, 2, 2, 3576, 3561, 3, 2, 2, 2, 3576, 3569, 3, 2, 2, 2, 3577, 341, 3, 2, 2, 2, 3578, 3579, 7, 273, 2, 2, 3579, 3580, 7, 4, 2, 2, 3580, 3581, 5, 344, 173, 2, 3581, 3582, 7, 5, 2, 2, 3582, 3585, 3, 2, 2, 2, 3583, 3585, 3, 2, 2, 2, 3584, 3578, 3, 2, 2, 2, 3584, 3583, 3, 2, 2, 2, 3585, 343, 3, 2, 2, 2, 3586, 3591, 5, 352, 177, 2, 3587, 3588, 7, 8, 2, 2, 3588, 3590, 5, 352, 177, 2, 3589, 3587, 3, 2, 2, 2, 3590, 3593, 3, 2, 2, 2, 3591, 3589, 3, 2, 2, 2, 3591, 3592, 3, 2, 2, 2, 3592, 345, 3, 2, 2, 2, 3593, 3591, 3, 2, 2, 2, 3594, 3595, 7, 273, 2, 2, 3595, 3596, 7, 4, 2, 2, 3596, 3597, 5, 348, 175, 2, 3597, 3598, 7, 5, 2, 2, 3598, 347, 3, 2, 2, 2, 3599, 3604, 5, 350, 176, 2, 3600, 3601, 7, 8, 2, 2, 3601, 3603, 5, 350, 176, 2, 3602, 3600, 3, 2, 2, 2, 3603, 3606, 3, 2, 2, 2, 3604, 3602, 3, 2, 2, 2, 3604, 3605, 3, 2, 2, 2, 3605, 349, 3, 2, 2, 2, 3606, 3604, 3, 2, 2, 2, 3607, 3615, 5, 352, 177, 2, 3608, 3609, 7, 326, 2, 2, 3609, 3615, 5, 352, 177, 2, 3610, 3611, 7, 135, 2, 2, 3611, 3615, 5, 352, 177, 2, 3612, 3613, 7, 193, 2, 2, 3613, 3615, 5, 354, 178, 2, 3614, 3607, 3, 2, 2, 2, 3614, 3608, 3, 2, 2, 2, 3614, 3610, 3, 2, 2, 2, 3614, 3612, 3, 2, 2, 2, 3615, 351, 3, 2, 2, 2, 3616, 3617, 5, 354, 178, 2, 3617, 3618, 5, 356, 179, 2, 3618, 353, 3, 2, 2, 2, 3619, 3620, 5, 1368, 685, 2, 3620, 355, 3, 2, 2, 2, 3621, 3622, 5, 1348, 675, 2, 3622, 357, 3, 2, 2, 2, 3623, 3624, 7, 48, 2, 2, 3624, 3625, 7, 324, 2, 2, 3625, 3626, 5, 1330, 666, 2, 3626, 3627, 5, 360, 181, 2, 3627, 3628, 5, 364, 183, 2, 3628, 3629, 7, 65, 2, 2, 3629, 3630, 7, 176, 2, 2, 3630, 3631, 7, 374, 2, 2, 3631, 3632, 5, 1330, 666, 2, 3632, 3633, 5, 342, 172, 2, 3633, 3649, 3, 2, 2, 2, 3634, 3635, 7, 48, 2, 2, 3635, 3636, 7, 324, 2, 2, 3636, 3637, 7, 222, 2, 2, 3637, 3638, 7, 79, 2, 2, 3638, 3639, 7, 389, 2, 2, 3639, 3640, 5, 1330, 666, 2, 3640, 3641, 5, 360, 181, 2, 3641, 3642, 5, 364, 183, 2, 3642, 3643, 7, 65, 2, 2, 3643, 3644, 7, 176, 2, 2, 3644, 3645, 7, 374, 2, 2, 3645, 3646, 5, 1330, 666, 2, 3646, 3647, 5, 342, 172, 2, 3647, 3649, 3, 2, 2, 2, 3648, 3623, 3, 2, 2, 2, 3648, 3634, 3, 2, 2, 2, 3649, 359, 3, 2, 2, 2, 3650, 3651, 7, 353, 2, 2, 3651, 3654, 5, 1348, 675, 2, 3652, 3654, 3, 2, 2, 2, 3653, 3650, 3, 2, 2, 2, 3653, 3652, 3, 2, 2, 2, 3654, 361, 3, 2, 2, 2, 3655, 3658, 7, 368, 2, 2, 3656, 3659, 5, 1348, 675, 2, 3657, 3659, 7, 80, 2, 2, 3658, 3656, 3, 2, 2, 2, 3658, 3657, 3, 2, 2, 2, 3659, 363, 3, 2, 2, 2, 3660, 3663, 5, 362, 182, 2, 3661, 3663, 3, 2, 2, 2, 3662, 3660, 3, 2, 2, 2, 3662, 3661, 3, 2, 2, 2, 3663, 365, 3, 2, 2, 2, 3664, 3665, 7, 140, 2, 2, 3665, 3666, 7, 324, 2, 2, 3666, 3672, 5, 1330, 666, 2, 3667, 3673, 5, 346, 174, 2, 3668, 3670, 5, 362, 182, 2, 3669, 3671, 5, 346, 174, 2, 3670, 3669, 3, 2, 2, 2, 3670, 3671, 3, 2, 2, 2, 3671, 3673, 3, 2, 2, 2, 3672, 3667, 3, 2, 2, 2, 3672, 3668, 3, 2, 2, 2, 3673, 367, 3, 2, 2, 2, 3674, 3675, 7, 48, 2, 2, 3675, 3676, 7, 65, 2, 2, 3676, 3677, 7, 94, 2, 2, 3677, 3678, 5, 1326, 664, 2, 3678, 3679, 7, 4, 2, 2, 3679, 3680, 5, 178, 90, 2, 3680, 3681, 7, 5, 2, 2, 3681, 3682, 5, 240, 121, 2, 3682, 3683, 7, 324, 2, 2, 3683, 3684, 5, 1330, 666, 2, 3684, 3685, 5, 342, 172, 2, 3685, 3731, 3, 2, 2, 2, 3686, 3687, 7, 48, 2, 2, 3687, 3688, 7, 65, 2, 2, 3688, 3689, 7, 94, 2, 2, 3689, 3690, 7, 222, 2, 2, 3690, 3691, 7, 79, 2, 2, 3691, 3692, 7, 389, 2, 2, 3692, 3693, 5, 1326, 664, 2, 3693, 3694, 7, 4, 2, 2, 3694, 3695, 5, 178, 90, 2, 3695, 3696, 7, 5, 2, 2, 3696, 3697, 5, 240, 121, 2, 3697, 3698, 7, 324, 2, 2, 3698, 3699, 5, 1330, 666, 2, 3699, 3700, 5, 342, 172, 2, 3700, 3731, 3, 2, 2, 2, 3701, 3702, 7, 48, 2, 2, 3702, 3703, 7, 65, 2, 2, 3703, 3704, 7, 94, 2, 2, 3704, 3705, 5, 1326, 664, 2, 3705, 3706, 7, 278, 2, 2, 3706, 3707, 7, 268, 2, 2, 3707, 3708, 5, 1326, 664, 2, 3708, 3709, 5, 180, 91, 2, 3709, 3710, 5, 130, 66, 2, 3710, 3711, 7, 324, 2, 2, 3711, 3712, 5, 1330, 666, 2, 3712, 3713, 5, 342, 172, 2, 3713, 3731, 3, 2, 2, 2, 3714, 3715, 7, 48, 2, 2, 3715, 3716, 7, 65, 2, 2, 3716, 3717, 7, 94, 2, 2, 3717, 3718, 7, 222, 2, 2, 3718, 3719, 7, 79, 2, 2, 3719, 3720, 7, 389, 2, 2, 3720, 3721, 5, 1326, 664, 2, 3721, 3722, 7, 278, 2, 2, 3722, 3723, 7, 268, 2, 2, 3723, 3724, 5, 1326, 664, 2, 3724, 3725, 5, 180, 91, 2, 3725, 3726, 5, 130, 66, 2, 3726, 3727, 7, 324, 2, 2, 3727, 3728, 5, 1330, 666, 2, 3728, 3729, 5, 342, 172, 2, 3729, 3731, 3, 2, 2, 2, 3730, 3674, 3, 2, 2, 2, 3730, 3686, 3, 2, 2, 2, 3730, 3701, 3, 2, 2, 2, 3730, 3714, 3, 2, 2, 2, 3731, 369, 3, 2, 2, 2, 3732, 3733, 7, 437, 2, 2, 3733, 3734, 7, 65, 2, 2, 3734, 3735, 7, 316, 2, 2, 3735, 3736, 5, 1330, 666, 2, 3736, 3737, 5, 374, 188, 2, 3737, 3738, 7, 66, 2, 2, 3738, 3739, 7, 324, 2, 2, 3739, 3740, 5, 1330, 666, 2, 3740, 3741, 7, 73, 2, 2, 3741, 3742, 5, 1330, 666, 2, 3742, 3743, 5, 342, 172, 2, 3743, 371, 3, 2, 2, 2, 3744, 3745, 7, 76, 2, 2, 3745, 3748, 7, 96, 2, 2, 3746, 3748, 7, 61, 2, 2, 3747, 3744, 3, 2, 2, 2, 3747, 3746, 3, 2, 2, 2, 3748, 373, 3, 2, 2, 2, 3749, 3750, 5, 372, 187, 2, 3750, 3751, 7, 4, 2, 2, 3751, 3752, 5, 1068, 535, 2, 3752, 3753, 7, 5, 2, 2, 3753, 3756, 3, 2, 2, 2, 3754, 3756, 3, 2, 2, 2, 3755, 3749, 3, 2, 2, 2, 3755, 3754, 3, 2, 2, 2, 3756, 375, 3, 2, 2, 2, 3757, 3758, 7, 48, 2, 2, 3758, 3759, 7, 101, 2, 2, 3759, 3760, 7, 250, 2, 2, 3760, 3761, 7, 64, 2, 2, 3761, 3762, 5, 378, 190, 2, 3762, 3763, 7, 324, 2, 2, 3763, 3764, 5, 1330, 666, 2, 3764, 3765, 5, 342, 172, 2, 3765, 3779, 3, 2, 2, 2, 3766, 3767, 7, 48, 2, 2, 3767, 3768, 7, 101, 2, 2, 3768, 3769, 7, 250, 2, 2, 3769, 3770, 7, 222, 2, 2, 3770, 3771, 7, 79, 2, 2, 3771, 3772, 7, 389, 2, 2, 3772, 3773, 7, 64, 2, 2, 3773, 3774, 5, 378, 190, 2, 3774, 3775, 7, 324, 2, 2, 3775, 3776, 5, 1330, 666, 2, 3776, 3777, 5, 342, 172, 2, 3777, 3779, 3, 2, 2, 2, 3778, 3757, 3, 2, 2, 2, 3778, 3766, 3, 2, 2, 2, 3779, 377, 3, 2, 2, 2, 3780, 3783, 5, 1358, 680, 2, 3781, 3783, 7, 101, 2, 2, 3782, 3780, 3, 2, 2, 2, 3782, 3781, 3, 2, 2, 2, 3783, 379, 3, 2, 2, 2, 3784, 3785, 7, 193, 2, 2, 3785, 3786, 7, 101, 2, 2, 3786, 3787, 7, 250, 2, 2, 3787, 3788, 7, 64, 2, 2, 3788, 3789, 5, 378, 190, 2, 3789, 3790, 7, 324, 2, 2, 3790, 3791, 5, 1330, 666, 2, 3791, 3803, 3, 2, 2, 2, 3792, 3793, 7, 193, 2, 2, 3793, 3794, 7, 101, 2, 2, 3794, 3795, 7, 250, 2, 2, 3795, 3796, 7, 222, 2, 2, 3796, 3797, 7, 389, 2, 2, 3797, 3798, 7, 64, 2, 2, 3798, 3799, 5, 378, 190, 2, 3799, 3800, 7, 324, 2, 2, 3800, 3801, 5, 1330, 666, 2, 3801, 3803, 3, 2, 2, 2, 3802, 3784, 3, 2, 2, 2, 3802, 3792, 3, 2, 2, 2, 3803, 381, 3, 2, 2, 2, 3804, 3805, 7, 140, 2, 2, 3805, 3806, 7, 101, 2, 2, 3806, 3807, 7, 250, 2, 2, 3807, 3808, 7, 64, 2, 2, 3808, 3809, 5, 378, 190, 2, 3809, 3810, 7, 324, 2, 2, 3810, 3811, 5, 1330, 666, 2, 3811, 3812, 5, 346, 174, 2, 3812, 383, 3, 2, 2, 2, 3813, 3814, 7, 48, 2, 2, 3814, 3815, 7, 438, 2, 2, 3815, 3816, 5, 1330, 666, 2, 3816, 3817, 7, 82, 2, 2, 3817, 3818, 5, 1326, 664, 2, 3818, 3819, 5, 396, 199, 2, 3819, 3820, 5, 398, 200, 2, 3820, 3821, 5, 392, 197, 2, 3821, 3822, 5, 388, 195, 2, 3822, 3823, 5, 390, 196, 2, 3823, 385, 3, 2, 2, 2, 3824, 3825, 7, 140, 2, 2, 3825, 3826, 7, 438, 2, 2, 3826, 3827, 5, 1330, 666, 2, 3827, 3828, 7, 82, 2, 2, 3828, 3829, 5, 1326, 664, 2, 3829, 3830, 5, 394, 198, 2, 3830, 3831, 5, 388, 195, 2, 3831, 3832, 5, 390, 196, 2, 3832, 387, 3, 2, 2, 2, 3833, 3834, 7, 102, 2, 2, 3834, 3835, 7, 4, 2, 2, 3835, 3836, 5, 1154, 578, 2, 3836, 3837, 7, 5, 2, 2, 3837, 3840, 3, 2, 2, 2, 3838, 3840, 3, 2, 2, 2, 3839, 3833, 3, 2, 2, 2, 3839, 3838, 3, 2, 2, 2, 3840, 389, 3, 2, 2, 2, 3841, 3842, 7, 107, 2, 2, 3842, 3843, 7, 44, 2, 2, 3843, 3844, 7, 4, 2, 2, 3844, 3845, 5, 1154, 578, 2, 3845, 3846, 7, 5, 2, 2, 3846, 3849, 3, 2, 2, 2, 3847, 3849, 3, 2, 2, 2, 3848, 3841, 3, 2, 2, 2, 3848, 3847, 3, 2, 2, 2, 3849, 391, 3, 2, 2, 2, 3850, 3851, 7, 96, 2, 2, 3851, 3854, 5, 1360, 681, 2, 3852, 3854, 3, 2, 2, 2, 3853, 3850, 3, 2, 2, 2, 3853, 3852, 3, 2, 2, 2, 3854, 393, 3, 2, 2, 2, 3855, 3856, 7, 96, 2, 2, 3856, 3859, 5, 1360, 681, 2, 3857, 3859, 3, 2, 2, 2, 3858, 3855, 3, 2, 2, 2, 3858, 3857, 3, 2, 2, 2, 3859, 395, 3, 2, 2, 2, 3860, 3861, 7, 38, 2, 2, 3861, 3864, 5, 1370, 686, 2, 3862, 3864, 3, 2, 2, 2, 3863, 3860, 3, 2, 2, 2, 3863, 3862, 3, 2, 2, 2, 3864, 397, 3, 2, 2, 2, 3865, 3866, 7, 64, 2, 2, 3866, 3869, 5, 400, 201, 2, 3867, 3869, 3, 2, 2, 2, 3868, 3865, 3, 2, 2, 2, 3868, 3867, 3, 2, 2, 2, 3869, 399, 3, 2, 2, 2, 3870, 3871, 9, 19, 2, 2, 3871, 401, 3, 2, 2, 2, 3872, 3873, 7, 48, 2, 2, 3873, 3874, 7, 133, 2, 2, 3874, 3875, 7, 439, 2, 2, 3875, 3876, 5, 1330, 666, 2, 3876, 3877, 7, 353, 2, 2, 3877, 3878, 5, 404, 203, 2, 3878, 3879, 7, 217, 2, 2, 3879, 3880, 5, 302, 152, 2, 3880, 403, 3, 2, 2, 2, 3881, 3882, 9, 20, 2, 2, 3882, 405, 3, 2, 2, 2, 3883, 3884, 7, 48, 2, 2, 3884, 3885, 7, 350, 2, 2, 3885, 3886, 5, 1330, 666, 2, 3886, 3887, 5, 408, 205, 2, 3887, 3888, 5, 410, 206, 2, 3888, 3889, 7, 82, 2, 2, 3889, 3890, 5, 1326, 664, 2, 3890, 3891, 5, 414, 208, 2, 3891, 3892, 5, 426, 214, 2, 3892, 3893, 5, 432, 217, 2, 3893, 3894, 7, 204, 2, 2, 3894, 3895, 5, 434, 218, 2, 3895, 3896, 5, 1336, 669, 2, 3896, 3897, 7, 4, 2, 2, 3897, 3898, 5, 436, 219, 2, 3898, 3899, 7, 5, 2, 2, 3899, 3922, 3, 2, 2, 2, 3900, 3901, 7, 48, 2, 2, 3901, 3902, 7, 47, 2, 2, 3902, 3903, 7, 350, 2, 2, 3903, 3904, 5, 1330, 666, 2, 3904, 3905, 7, 137, 2, 2, 3905, 3906, 5, 410, 206, 2, 3906, 3907, 7, 82, 2, 2, 3907, 3908, 5, 1326, 664, 2, 3908, 3909, 5, 440, 221, 2, 3909, 3910, 5, 442, 222, 2, 3910, 3911, 7, 64, 2, 2, 3911, 3912, 7, 194, 2, 2, 3912, 3913, 7, 407, 2, 2, 3913, 3914, 5, 432, 217, 2, 3914, 3915, 7, 204, 2, 2, 3915, 3916, 5, 434, 218, 2, 3916, 3917, 5, 1336, 669, 2, 3917, 3918, 7, 4, 2, 2, 3918, 3919, 5, 436, 219, 2, 3919, 3920, 7, 5, 2, 2, 3920, 3922, 3, 2, 2, 2, 3921, 3883, 3, 2, 2, 2, 3921, 3900, 3, 2, 2, 2, 3922, 407, 3, 2, 2, 2, 3923, 3928, 7, 147, 2, 2, 3924, 3928, 7, 137, 2, 2, 3925, 3926, 7, 235, 2, 2, 3926, 3928, 7, 268, 2, 2, 3927, 3923, 3, 2, 2, 2, 3927, 3924, 3, 2, 2, 2, 3927, 3925, 3, 2, 2, 2, 3928, 409, 3, 2, 2, 2, 3929, 3934, 5, 412, 207, 2, 3930, 3931, 7, 84, 2, 2, 3931, 3933, 5, 412, 207, 2, 3932, 3930, 3, 2, 2, 2, 3933, 3936, 3, 2, 2, 2, 3934, 3932, 3, 2, 2, 2, 3934, 3935, 3, 2, 2, 2, 3935, 411, 3, 2, 2, 2, 3936, 3934, 3, 2, 2, 2, 3937, 3945, 7, 234, 2, 2, 3938, 3945, 7, 184, 2, 2, 3939, 3945, 7, 362, 2, 2, 3940, 3941, 7, 362, 2, 2, 3941, 3942, 7, 268, 2, 2, 3942, 3945, 5, 218, 110, 2, 3943, 3945, 7, 351, 2, 2, 3944, 3937, 3, 2, 2, 2, 3944, 3938, 3, 2, 2, 2, 3944, 3939, 3, 2, 2, 2, 3944, 3940, 3, 2, 2, 2, 3944, 3943, 3, 2, 2, 2, 3945, 413, 3, 2, 2, 2, 3946, 3947, 7, 440, 2, 2, 3947, 3950, 5, 416, 209, 2, 3948, 3950, 3, 2, 2, 2, 3949, 3946, 3, 2, 2, 2, 3949, 3948, 3, 2, 2, 2, 3950, 415, 3, 2, 2, 2, 3951, 3953, 5, 418, 210, 2, 3952, 3951, 3, 2, 2, 2, 3953, 3954, 3, 2, 2, 2, 3954, 3952, 3, 2, 2, 2, 3954, 3955, 3, 2, 2, 2, 3955, 417, 3, 2, 2, 2, 3956, 3957, 5, 420, 211, 2, 3957, 3958, 5, 422, 212, 2, 3958, 3959, 5, 836, 419, 2, 3959, 3960, 5, 424, 213, 2, 3960, 419, 3, 2, 2, 2, 3961, 3962, 9, 21, 2, 2, 3962, 421, 3, 2, 2, 2, 3963, 3964, 9, 22, 2, 2, 3964, 423, 3, 2, 2, 2, 3965, 3966, 5, 1362, 682, 2, 3966, 425, 3, 2, 2, 2, 3967, 3968, 7, 64, 2, 2, 3968, 3969, 5, 428, 215, 2, 3969, 3970, 5, 430, 216, 2, 3970, 3973, 3, 2, 2, 2, 3971, 3973, 3, 2, 2, 2, 3972, 3967, 3, 2, 2, 2, 3972, 3971, 3, 2, 2, 2, 3973, 427, 3, 2, 2, 2, 3974, 3977, 7, 194, 2, 2, 3975, 3977, 3, 2, 2, 2, 3976, 3974, 3, 2, 2, 2, 3976, 3975, 3, 2, 2, 2, 3977, 429, 3, 2, 2, 2, 3978, 3979, 9, 23, 2, 2, 3979, 431, 3, 2, 2, 2, 3980, 3981, 7, 104, 2, 2, 3981, 3982, 7, 4, 2, 2, 3982, 3983, 5, 1154, 578, 2, 3983, 3984, 7, 5, 2, 2, 3984, 3987, 3, 2, 2, 2, 3985, 3987, 3, 2, 2, 2, 3986, 3980, 3, 2, 2, 2, 3986, 3985, 3, 2, 2, 2, 3987, 433, 3, 2, 2, 2, 3988, 3989, 9, 24, 2, 2, 3989, 435, 3, 2, 2, 2, 3990, 3993, 5, 438, 220, 2, 3991, 3993, 3, 2, 2, 2, 3992, 3990, 3, 2, 2, 2, 3992, 3991, 3, 2, 2, 2, 3993, 3998, 3, 2, 2, 2, 3994, 3995, 7, 8, 2, 2, 3995, 3997, 5, 438, 220, 2, 3996, 3994, 3, 2, 2, 2, 3997, 4000, 3, 2, 2, 2, 3998, 3996, 3, 2, 2, 2, 3998, 3999, 3, 2, 2, 2, 3999, 437, 3, 2, 2, 2, 4000, 3998, 3, 2, 2, 2, 4001, 4006, 5, 1346, 674, 2, 4002, 4006, 5, 1344, 673, 2, 4003, 4006, 5, 1348, 675, 2, 4004, 4006, 5, 1368, 685, 2, 4005, 4001, 3, 2, 2, 2, 4005, 4002, 3, 2, 2, 2, 4005, 4003, 3, 2, 2, 2, 4005, 4004, 3, 2, 2, 2, 4006, 439, 3, 2, 2, 2, 4007, 4008, 7, 66, 2, 2, 4008, 4011, 5, 1326, 664, 2, 4009, 4011, 3, 2, 2, 2, 4010, 4007, 3, 2, 2, 2, 4010, 4009, 3, 2, 2, 2, 4011, 441, 3, 2, 2, 2, 4012, 4014, 5, 444, 223, 2, 4013, 4012, 3, 2, 2, 2, 4014, 4017, 3, 2, 2, 2, 4015, 4013, 3, 2, 2, 2, 4015, 4016, 3, 2, 2, 2, 4016, 443, 3, 2, 2, 2, 4017, 4015, 3, 2, 2, 2, 4018, 4019, 7, 79, 2, 2, 4019, 4030, 7, 56, 2, 2, 4020, 4030, 7, 56, 2, 2, 4021, 4022, 7, 71, 2, 2, 4022, 4030, 7, 223, 2, 2, 4023, 4024, 7, 71, 2, 2, 4024, 4030, 7, 182, 2, 2, 4025, 4026, 7, 79, 2, 2, 4026, 4030, 7, 364, 2, 2, 4027, 4028, 7, 262, 2, 2, 4028, 4030, 7, 230, 2, 2, 4029, 4018, 3, 2, 2, 2, 4029, 4020, 3, 2, 2, 2, 4029, 4021, 3, 2, 2, 2, 4029, 4023, 3, 2, 2, 2, 4029, 4025, 3, 2, 2, 2, 4029, 4027, 3, 2, 2, 2, 4030, 445, 3, 2, 2, 2, 4031, 4032, 7, 48, 2, 2, 4032, 4033, 7, 200, 2, 2, 4033, 4034, 7, 350, 2, 2, 4034, 4035, 5, 1330, 666, 2, 4035, 4036, 7, 82, 2, 2, 4036, 4037, 5, 1368, 685, 2, 4037, 4038, 7, 204, 2, 2, 4038, 4039, 5, 434, 218, 2, 4039, 4040, 5, 1336, 669, 2, 4040, 4041, 7, 4, 2, 2, 4041, 4042, 7, 5, 2, 2, 4042, 4058, 3, 2, 2, 2, 4043, 4044, 7, 48, 2, 2, 4044, 4045, 7, 200, 2, 2, 4045, 4046, 7, 350, 2, 2, 4046, 4047, 5, 1330, 666, 2, 4047, 4048, 7, 82, 2, 2, 4048, 4049, 5, 1368, 685, 2, 4049, 4050, 7, 104, 2, 2, 4050, 4051, 5, 448, 225, 2, 4051, 4052, 7, 204, 2, 2, 4052, 4053, 5, 434, 218, 2, 4053, 4054, 5, 1336, 669, 2, 4054, 4055, 7, 4, 2, 2, 4055, 4056, 7, 5, 2, 2, 4056, 4058, 3, 2, 2, 2, 4057, 4031, 3, 2, 2, 2, 4057, 4043, 3, 2, 2, 2, 4058, 447, 3, 2, 2, 2, 4059, 4064, 5, 450, 226, 2, 4060, 4061, 7, 35, 2, 2, 4061, 4063, 5, 450, 226, 2, 4062, 4060, 3, 2, 2, 2, 4063, 4066, 3, 2, 2, 2, 4064, 4062, 3, 2, 2, 2, 4064, 4065, 3, 2, 2, 2, 4065, 449, 3, 2, 2, 2, 4066, 4064, 3, 2, 2, 2, 4067, 4068, 5, 1362, 682, 2, 4068, 4069, 7, 70, 2, 2, 4069, 4070, 7, 4, 2, 2, 4070, 4071, 5, 452, 227, 2, 4071, 4072, 7, 5, 2, 2, 4072, 451, 3, 2, 2, 2, 4073, 4078, 5, 1348, 675, 2, 4074, 4075, 7, 8, 2, 2, 4075, 4077, 5, 1348, 675, 2, 4076, 4074, 3, 2, 2, 2, 4077, 4080, 3, 2, 2, 2, 4078, 4076, 3, 2, 2, 2, 4078, 4079, 3, 2, 2, 2, 4079, 453, 3, 2, 2, 2, 4080, 4078, 3, 2, 2, 2, 4081, 4082, 7, 140, 2, 2, 4082, 4083, 7, 200, 2, 2, 4083, 4084, 7, 350, 2, 2, 4084, 4085, 5, 1330, 666, 2, 4085, 4086, 5, 456, 229, 2, 4086, 455, 3, 2, 2, 2, 4087, 4094, 7, 195, 2, 2, 4088, 4089, 7, 195, 2, 2, 4089, 4094, 7, 305, 2, 2, 4090, 4091, 7, 195, 2, 2, 4091, 4094, 7, 141, 2, 2, 4092, 4094, 7, 188, 2, 2, 4093, 4087, 3, 2, 2, 2, 4093, 4088, 3, 2, 2, 2, 4093, 4090, 3, 2, 2, 2, 4093, 4092, 3, 2, 2, 2, 4094, 457, 3, 2, 2, 2, 4095, 4096, 7, 48, 2, 2, 4096, 4097, 7, 142, 2, 2, 4097, 4098, 5, 526, 264, 2, 4098, 4099, 7, 44, 2, 2, 4099, 4100, 7, 4, 2, 2, 4100, 4101, 5, 1154, 578, 2, 4101, 4102, 7, 5, 2, 2, 4102, 4103, 5, 442, 222, 2, 4103, 459, 3, 2, 2, 2, 4104, 4105, 7, 48, 2, 2, 4105, 4106, 5, 620, 311, 2, 4106, 4107, 7, 138, 2, 2, 4107, 4108, 5, 1336, 669, 2, 4108, 4109, 5, 648, 325, 2, 4109, 4110, 5, 462, 232, 2, 4110, 4211, 3, 2, 2, 2, 4111, 4112, 7, 48, 2, 2, 4112, 4113, 5, 620, 311, 2, 4113, 4114, 7, 138, 2, 2, 4114, 4115, 5, 1336, 669, 2, 4115, 4116, 5, 470, 236, 2, 4116, 4211, 3, 2, 2, 2, 4117, 4118, 7, 48, 2, 2, 4118, 4119, 7, 271, 2, 2, 4119, 4120, 5, 686, 344, 2, 4120, 4121, 5, 462, 232, 2, 4121, 4211, 3, 2, 2, 2, 4122, 4123, 7, 48, 2, 2, 4123, 4124, 7, 353, 2, 2, 4124, 4125, 5, 526, 264, 2, 4125, 4126, 5, 462, 232, 2, 4126, 4211, 3, 2, 2, 2, 4127, 4128, 7, 48, 2, 2, 4128, 4129, 7, 353, 2, 2, 4129, 4211, 5, 526, 264, 2, 4130, 4131, 7, 48, 2, 2, 4131, 4132, 7, 353, 2, 2, 4132, 4133, 5, 526, 264, 2, 4133, 4134, 7, 38, 2, 2, 4134, 4135, 7, 4, 2, 2, 4135, 4136, 5, 1090, 546, 2, 4136, 4137, 7, 5, 2, 2, 4137, 4211, 3, 2, 2, 2, 4138, 4139, 7, 48, 2, 2, 4139, 4140, 7, 353, 2, 2, 4140, 4141, 5, 526, 264, 2, 4141, 4142, 7, 38, 2, 2, 4142, 4143, 7, 198, 2, 2, 4143, 4144, 7, 4, 2, 2, 4144, 4145, 5, 476, 239, 2, 4145, 4146, 7, 5, 2, 2, 4146, 4211, 3, 2, 2, 2, 4147, 4148, 7, 48, 2, 2, 4148, 4149, 7, 353, 2, 2, 4149, 4150, 5, 526, 264, 2, 4150, 4151, 7, 38, 2, 2, 4151, 4152, 7, 292, 2, 2, 4152, 4153, 5, 462, 232, 2, 4153, 4211, 3, 2, 2, 2, 4154, 4155, 7, 48, 2, 2, 4155, 4156, 7, 348, 2, 2, 4156, 4157, 7, 318, 2, 2, 4157, 4158, 7, 276, 2, 2, 4158, 4159, 5, 526, 264, 2, 4159, 4160, 5, 462, 232, 2, 4160, 4211, 3, 2, 2, 2, 4161, 4162, 7, 48, 2, 2, 4162, 4163, 7, 348, 2, 2, 4163, 4164, 7, 318, 2, 2, 4164, 4165, 7, 187, 2, 2, 4165, 4166, 5, 526, 264, 2, 4166, 4167, 5, 462, 232, 2, 4167, 4211, 3, 2, 2, 2, 4168, 4169, 7, 48, 2, 2, 4169, 4170, 7, 348, 2, 2, 4170, 4171, 7, 318, 2, 2, 4171, 4172, 7, 346, 2, 2, 4172, 4173, 5, 526, 264, 2, 4173, 4174, 5, 462, 232, 2, 4174, 4211, 3, 2, 2, 2, 4175, 4176, 7, 48, 2, 2, 4176, 4177, 7, 348, 2, 2, 4177, 4178, 7, 318, 2, 2, 4178, 4179, 7, 165, 2, 2, 4179, 4180, 5, 526, 264, 2, 4180, 4181, 5, 462, 232, 2, 4181, 4211, 3, 2, 2, 2, 4182, 4183, 7, 48, 2, 2, 4183, 4184, 7, 110, 2, 2, 4184, 4185, 5, 526, 264, 2, 4185, 4186, 5, 462, 232, 2, 4186, 4211, 3, 2, 2, 2, 4187, 4188, 7, 48, 2, 2, 4188, 4189, 7, 110, 2, 2, 4189, 4190, 7, 222, 2, 2, 4190, 4191, 7, 79, 2, 2, 4191, 4192, 7, 389, 2, 2, 4192, 4193, 5, 526, 264, 2, 4193, 4194, 5, 462, 232, 2, 4194, 4211, 3, 2, 2, 2, 4195, 4196, 7, 48, 2, 2, 4196, 4197, 7, 110, 2, 2, 4197, 4198, 5, 526, 264, 2, 4198, 4199, 7, 66, 2, 2, 4199, 4200, 5, 526, 264, 2, 4200, 4211, 3, 2, 2, 2, 4201, 4202, 7, 48, 2, 2, 4202, 4203, 7, 110, 2, 2, 4203, 4204, 7, 222, 2, 2, 4204, 4205, 7, 79, 2, 2, 4205, 4206, 7, 389, 2, 2, 4206, 4207, 5, 526, 264, 2, 4207, 4208, 7, 66, 2, 2, 4208, 4209, 5, 526, 264, 2, 4209, 4211, 3, 2, 2, 2, 4210, 4104, 3, 2, 2, 2, 4210, 4111, 3, 2, 2, 2, 4210, 4117, 3, 2, 2, 2, 4210, 4122, 3, 2, 2, 2, 4210, 4127, 3, 2, 2, 2, 4210, 4130, 3, 2, 2, 2, 4210, 4138, 3, 2, 2, 2, 4210, 4147, 3, 2, 2, 2, 4210, 4154, 3, 2, 2, 2, 4210, 4161, 3, 2, 2, 2, 4210, 4168, 3, 2, 2, 2, 4210, 4175, 3, 2, 2, 2, 4210, 4182, 3, 2, 2, 2, 4210, 4187, 3, 2, 2, 2, 4210, 4195, 3, 2, 2, 2, 4210, 4201, 3, 2, 2, 2, 4211, 461, 3, 2, 2, 2, 4212, 4213, 7, 4, 2, 2, 4213, 4214, 5, 464, 233, 2, 4214, 4215, 7, 5, 2, 2, 4215, 463, 3, 2, 2, 2, 4216, 4221, 5, 466, 234, 2, 4217, 4218, 7, 8, 2, 2, 4218, 4220, 5, 466, 234, 2, 4219, 4217, 3, 2, 2, 2, 4220, 4223, 3, 2, 2, 2, 4221, 4219, 3, 2, 2, 2, 4221, 4222, 3, 2, 2, 2, 4222, 465, 3, 2, 2, 2, 4223, 4221, 3, 2, 2, 2, 4224, 4227, 5, 1368, 685, 2, 4225, 4226, 7, 12, 2, 2, 4226, 4228, 5, 468, 235, 2, 4227, 4225, 3, 2, 2, 2, 4227, 4228, 3, 2, 2, 2, 4228, 467, 3, 2, 2, 2, 4229, 4236, 5, 642, 322, 2, 4230, 4236, 5, 1380, 691, 2, 4231, 4236, 5, 1266, 634, 2, 4232, 4236, 5, 294, 148, 2, 4233, 4236, 5, 1348, 675, 2, 4234, 4236, 7, 400, 2, 2, 4235, 4229, 3, 2, 2, 2, 4235, 4230, 3, 2, 2, 2, 4235, 4231, 3, 2, 2, 2, 4235, 4232, 3, 2, 2, 2, 4235, 4233, 3, 2, 2, 2, 4235, 4234, 3, 2, 2, 2, 4236, 469, 3, 2, 2, 2, 4237, 4238, 7, 4, 2, 2, 4238, 4239, 5, 472, 237, 2, 4239, 4240, 7, 5, 2, 2, 4240, 471, 3, 2, 2, 2, 4241, 4246, 5, 474, 238, 2, 4242, 4243, 7, 8, 2, 2, 4243, 4245, 5, 474, 238, 2, 4244, 4242, 3, 2, 2, 2, 4245, 4248, 3, 2, 2, 2, 4246, 4244, 3, 2, 2, 2, 4246, 4247, 3, 2, 2, 2, 4247, 473, 3, 2, 2, 2, 4248, 4246, 3, 2, 2, 2, 4249, 4250, 5, 1370, 686, 2, 4250, 4251, 7, 12, 2, 2, 4251, 4252, 5, 468, 235, 2, 4252, 475, 3, 2, 2, 2, 4253, 4256, 5, 478, 240, 2, 4254, 4256, 3, 2, 2, 2, 4255, 4253, 3, 2, 2, 2, 4255, 4254, 3, 2, 2, 2, 4256, 477, 3, 2, 2, 2, 4257, 4262, 5, 1348, 675, 2, 4258, 4259, 7, 8, 2, 2, 4259, 4261, 5, 1348, 675, 2, 4260, 4258, 3, 2, 2, 2, 4261, 4264, 3, 2, 2, 2, 4262, 4260, 3, 2, 2, 2, 4262, 4263, 3, 2, 2, 2, 4263, 479, 3, 2, 2, 2, 4264, 4262, 3, 2, 2, 2, 4265, 4266, 7, 140, 2, 2, 4266, 4267, 7, 353, 2, 2, 4267, 4268, 5, 526, 264, 2, 4268, 4269, 7, 135, 2, 2, 4269, 4270, 7, 443, 2, 2, 4270, 4271, 5, 482, 242, 2, 4271, 4272, 5, 1348, 675, 2, 4272, 4303, 3, 2, 2, 2, 4273, 4274, 7, 140, 2, 2, 4274, 4275, 7, 353, 2, 2, 4275, 4276, 5, 526, 264, 2, 4276, 4277, 7, 135, 2, 2, 4277, 4278, 7, 443, 2, 2, 4278, 4279, 5, 482, 242, 2, 4279, 4280, 5, 1348, 675, 2, 4280, 4281, 7, 147, 2, 2, 4281, 4282, 5, 1348, 675, 2, 4282, 4303, 3, 2, 2, 2, 4283, 4284, 7, 140, 2, 2, 4284, 4285, 7, 353, 2, 2, 4285, 4286, 5, 526, 264, 2, 4286, 4287, 7, 135, 2, 2, 4287, 4288, 7, 443, 2, 2, 4288, 4289, 5, 482, 242, 2, 4289, 4290, 5, 1348, 675, 2, 4290, 4291, 7, 137, 2, 2, 4291, 4292, 5, 1348, 675, 2, 4292, 4303, 3, 2, 2, 2, 4293, 4294, 7, 140, 2, 2, 4294, 4295, 7, 353, 2, 2, 4295, 4296, 5, 526, 264, 2, 4296, 4297, 7, 302, 2, 2, 4297, 4298, 7, 443, 2, 2, 4298, 4299, 5, 1348, 675, 2, 4299, 4300, 7, 96, 2, 2, 4300, 4301, 5, 1348, 675, 2, 4301, 4303, 3, 2, 2, 2, 4302, 4265, 3, 2, 2, 2, 4302, 4273, 3, 2, 2, 2, 4302, 4283, 3, 2, 2, 2, 4302, 4293, 3, 2, 2, 2, 4303, 481, 3, 2, 2, 2, 4304, 4305, 7, 222, 2, 2, 4305, 4306, 7, 79, 2, 2, 4306, 4309, 7, 389, 2, 2, 4307, 4309, 3, 2, 2, 2, 4308, 4304, 3, 2, 2, 2, 4308, 4307, 3, 2, 2, 2, 4309, 483, 3, 2, 2, 2, 4310, 4311, 7, 48, 2, 2, 4311, 4312, 7, 271, 2, 2, 4312, 4313, 7, 158, 2, 2, 4313, 4314, 5, 526, 264, 2, 4314, 4315, 5, 490, 246, 2, 4315, 4316, 7, 64, 2, 2, 4316, 4317, 7, 353, 2, 2, 4317, 4318, 5, 1110, 556, 2, 4318, 4319, 7, 102, 2, 2, 4319, 4320, 5, 1330, 666, 2, 4320, 4321, 5, 492, 247, 2, 4321, 4322, 7, 38, 2, 2, 4322, 4323, 5, 486, 244, 2, 4323, 485, 3, 2, 2, 2, 4324, 4329, 5, 488, 245, 2, 4325, 4326, 7, 8, 2, 2, 4326, 4328, 5, 488, 245, 2, 4327, 4325, 3, 2, 2, 2, 4328, 4331, 3, 2, 2, 2, 4329, 4327, 3, 2, 2, 2, 4329, 4330, 3, 2, 2, 2, 4330, 487, 3, 2, 2, 2, 4331, 4329, 3, 2, 2, 2, 4332, 4333, 7, 271, 2, 2, 4333, 4334, 5, 1346, 674, 2, 4334, 4335, 5, 686, 344, 2, 4335, 4336, 5, 494, 248, 2, 4336, 4337, 5, 496, 249, 2, 4337, 4358, 3, 2, 2, 2, 4338, 4339, 7, 271, 2, 2, 4339, 4340, 5, 1346, 674, 2, 4340, 4341, 5, 690, 346, 2, 4341, 4342, 5, 494, 248, 2, 4342, 4343, 5, 496, 249, 2, 4343, 4358, 3, 2, 2, 2, 4344, 4345, 7, 213, 2, 2, 4345, 4346, 5, 1346, 674, 2, 4346, 4347, 5, 628, 315, 2, 4347, 4358, 3, 2, 2, 2, 4348, 4349, 7, 213, 2, 2, 4349, 4350, 5, 1346, 674, 2, 4350, 4351, 7, 4, 2, 2, 4351, 4352, 5, 1276, 639, 2, 4352, 4353, 7, 5, 2, 2, 4353, 4354, 5, 628, 315, 2, 4354, 4358, 3, 2, 2, 2, 4355, 4356, 7, 338, 2, 2, 4356, 4358, 5, 1110, 556, 2, 4357, 4332, 3, 2, 2, 2, 4357, 4338, 3, 2, 2, 2, 4357, 4344, 3, 2, 2, 2, 4357, 4348, 3, 2, 2, 2, 4357, 4355, 3, 2, 2, 2, 4358, 489, 3, 2, 2, 2, 4359, 4362, 7, 55, 2, 2, 4360, 4362, 3, 2, 2, 2, 4361, 4359, 3, 2, 2, 2, 4361, 4360, 3, 2, 2, 2, 4362, 491, 3, 2, 2, 2, 4363, 4364, 7, 208, 2, 2, 4364, 4367, 5, 526, 264, 2, 4365, 4367, 3, 2, 2, 2, 4366, 4363, 3, 2, 2, 2, 4366, 4365, 3, 2, 2, 2, 4367, 493, 3, 2, 2, 2, 4368, 4369, 7, 64, 2, 2, 4369, 4376, 7, 318, 2, 2, 4370, 4371, 7, 64, 2, 2, 4371, 4372, 7, 85, 2, 2, 4372, 4373, 7, 149, 2, 2, 4373, 4376, 5, 526, 264, 2, 4374, 4376, 3, 2, 2, 2, 4375, 4368, 3, 2, 2, 2, 4375, 4370, 3, 2, 2, 2, 4375, 4374, 3, 2, 2, 2, 4376, 495, 3, 2, 2, 2, 4377, 4380, 7, 295, 2, 2, 4378, 4380, 3, 2, 2, 2, 4379, 4377, 3, 2, 2, 2, 4379, 4378, 3, 2, 2, 2, 4380, 497, 3, 2, 2, 2, 4381, 4382, 7, 48, 2, 2, 4382, 4383, 7, 271, 2, 2, 4383, 4384, 7, 208, 2, 2, 4384, 4385, 5, 526, 264, 2, 4385, 4386, 7, 102, 2, 2, 4386, 4387, 5, 1330, 666, 2, 4387, 499, 3, 2, 2, 2, 4388, 4389, 7, 140, 2, 2, 4389, 4390, 7, 271, 2, 2, 4390, 4391, 7, 208, 2, 2, 4391, 4392, 5, 526, 264, 2, 4392, 4393, 7, 102, 2, 2, 4393, 4394, 5, 1330, 666, 2, 4394, 4395, 7, 135, 2, 2, 4395, 4396, 5, 486, 244, 2, 4396, 4407, 3, 2, 2, 2, 4397, 4398, 7, 140, 2, 2, 4398, 4399, 7, 271, 2, 2, 4399, 4400, 7, 208, 2, 2, 4400, 4401, 5, 526, 264, 2, 4401, 4402, 7, 102, 2, 2, 4402, 4403, 5, 1330, 666, 2, 4403, 4404, 7, 193, 2, 2, 4404, 4405, 5, 502, 252, 2, 4405, 4407, 3, 2, 2, 2, 4406, 4388, 3, 2, 2, 2, 4406, 4397, 3, 2, 2, 2, 4407, 501, 3, 2, 2, 2, 4408, 4413, 5, 504, 253, 2, 4409, 4410, 7, 8, 2, 2, 4410, 4412, 5, 504, 253, 2, 4411, 4409, 3, 2, 2, 2, 4412, 4415, 3, 2, 2, 2, 4413, 4411, 3, 2, 2, 2, 4413, 4414, 3, 2, 2, 2, 4414, 503, 3, 2, 2, 2, 4415, 4413, 3, 2, 2, 2, 4416, 4417, 7, 271, 2, 2, 4417, 4418, 5, 1346, 674, 2, 4418, 4419, 7, 4, 2, 2, 4419, 4420, 5, 1276, 639, 2, 4420, 4421, 7, 5, 2, 2, 4421, 4429, 3, 2, 2, 2, 4422, 4423, 7, 213, 2, 2, 4423, 4424, 5, 1346, 674, 2, 4424, 4425, 7, 4, 2, 2, 4425, 4426, 5, 1276, 639, 2, 4426, 4427, 7, 5, 2, 2, 4427, 4429, 3, 2, 2, 2, 4428, 4416, 3, 2, 2, 2, 4428, 4422, 3, 2, 2, 2, 4429, 505, 3, 2, 2, 2, 4430, 4431, 7, 193, 2, 2, 4431, 4432, 7, 271, 2, 2, 4432, 4433, 7, 158, 2, 2, 4433, 4434, 5, 526, 264, 2, 4434, 4435, 7, 102, 2, 2, 4435, 4436, 5, 1330, 666, 2, 4436, 4437, 5, 110, 56, 2, 4437, 4449, 3, 2, 2, 2, 4438, 4439, 7, 193, 2, 2, 4439, 4440, 7, 271, 2, 2, 4440, 4441, 7, 158, 2, 2, 4441, 4442, 7, 222, 2, 2, 4442, 4443, 7, 389, 2, 2, 4443, 4444, 5, 526, 264, 2, 4444, 4445, 7, 102, 2, 2, 4445, 4446, 5, 1330, 666, 2, 4446, 4447, 5, 110, 56, 2, 4447, 4449, 3, 2, 2, 2, 4448, 4430, 3, 2, 2, 2, 4448, 4438, 3, 2, 2, 2, 4449, 507, 3, 2, 2, 2, 4450, 4451, 7, 193, 2, 2, 4451, 4452, 7, 271, 2, 2, 4452, 4453, 7, 208, 2, 2, 4453, 4454, 5, 526, 264, 2, 4454, 4455, 7, 102, 2, 2, 4455, 4456, 5, 1330, 666, 2, 4456, 4457, 5, 110, 56, 2, 4457, 4469, 3, 2, 2, 2, 4458, 4459, 7, 193, 2, 2, 4459, 4460, 7, 271, 2, 2, 4460, 4461, 7, 208, 2, 2, 4461, 4462, 7, 222, 2, 2, 4462, 4463, 7, 389, 2, 2, 4463, 4464, 5, 526, 264, 2, 4464, 4465, 7, 102, 2, 2, 4465, 4466, 5, 1330, 666, 2, 4466, 4467, 5, 110, 56, 2, 4467, 4469, 3, 2, 2, 2, 4468, 4450, 3, 2, 2, 2, 4468, 4458, 3, 2, 2, 2, 4469, 509, 3, 2, 2, 2, 4470, 4471, 7, 193, 2, 2, 4471, 4472, 7, 274, 2, 2, 4472, 4473, 7, 149, 2, 2, 4473, 4474, 5, 1360, 681, 2, 4474, 4475, 5, 110, 56, 2, 4475, 511, 3, 2, 2, 2, 4476, 4477, 7, 294, 2, 2, 4477, 4478, 7, 274, 2, 2, 4478, 4479, 7, 149, 2, 2, 4479, 4480, 5, 1360, 681, 2, 4480, 4481, 7, 96, 2, 2, 4481, 4482, 5, 1358, 680, 2, 4482, 513, 3, 2, 2, 2, 4483, 4484, 7, 193, 2, 2, 4484, 4485, 5, 516, 259, 2, 4485, 4486, 7, 222, 2, 2, 4486, 4487, 7, 389, 2, 2, 4487, 4488, 5, 524, 263, 2, 4488, 4489, 5, 110, 56, 2, 4489, 4562, 3, 2, 2, 2, 4490, 4491, 7, 193, 2, 2, 4491, 4492, 5, 516, 259, 2, 4492, 4493, 5, 524, 263, 2, 4493, 4494, 5, 110, 56, 2, 4494, 4562, 3, 2, 2, 2, 4495, 4496, 7, 193, 2, 2, 4496, 4497, 5, 520, 261, 2, 4497, 4498, 7, 222, 2, 2, 4498, 4499, 7, 389, 2, 2, 4499, 4500, 5, 1328, 665, 2, 4500, 4501, 5, 110, 56, 2, 4501, 4562, 3, 2, 2, 2, 4502, 4503, 7, 193, 2, 2, 4503, 4504, 5, 520, 261, 2, 4504, 4505, 5, 1328, 665, 2, 4505, 4506, 5, 110, 56, 2, 4506, 4562, 3, 2, 2, 2, 4507, 4508, 7, 193, 2, 2, 4508, 4509, 5, 522, 262, 2, 4509, 4510, 5, 1330, 666, 2, 4510, 4511, 7, 82, 2, 2, 4511, 4512, 5, 526, 264, 2, 4512, 4513, 5, 110, 56, 2, 4513, 4562, 3, 2, 2, 2, 4514, 4515, 7, 193, 2, 2, 4515, 4516, 5, 522, 262, 2, 4516, 4517, 7, 222, 2, 2, 4517, 4518, 7, 389, 2, 2, 4518, 4519, 5, 1330, 666, 2, 4519, 4520, 7, 82, 2, 2, 4520, 4521, 5, 526, 264, 2, 4521, 4522, 5, 110, 56, 2, 4522, 4562, 3, 2, 2, 2, 4523, 4524, 7, 193, 2, 2, 4524, 4525, 7, 353, 2, 2, 4525, 4526, 5, 530, 266, 2, 4526, 4527, 5, 110, 56, 2, 4527, 4562, 3, 2, 2, 2, 4528, 4529, 7, 193, 2, 2, 4529, 4530, 7, 353, 2, 2, 4530, 4531, 7, 222, 2, 2, 4531, 4532, 7, 389, 2, 2, 4532, 4533, 5, 530, 266, 2, 4533, 4534, 5, 110, 56, 2, 4534, 4562, 3, 2, 2, 2, 4535, 4536, 7, 193, 2, 2, 4536, 4537, 7, 191, 2, 2, 4537, 4538, 5, 530, 266, 2, 4538, 4539, 5, 110, 56, 2, 4539, 4562, 3, 2, 2, 2, 4540, 4541, 7, 193, 2, 2, 4541, 4542, 7, 191, 2, 2, 4542, 4543, 7, 222, 2, 2, 4543, 4544, 7, 389, 2, 2, 4544, 4545, 5, 530, 266, 2, 4545, 4546, 5, 110, 56, 2, 4546, 4562, 3, 2, 2, 2, 4547, 4548, 7, 193, 2, 2, 4548, 4549, 7, 228, 2, 2, 4549, 4550, 7, 111, 2, 2, 4550, 4551, 5, 524, 263, 2, 4551, 4552, 5, 110, 56, 2, 4552, 4562, 3, 2, 2, 2, 4553, 4554, 7, 193, 2, 2, 4554, 4555, 7, 228, 2, 2, 4555, 4556, 7, 111, 2, 2, 4556, 4557, 7, 222, 2, 2, 4557, 4558, 7, 389, 2, 2, 4558, 4559, 5, 524, 263, 2, 4559, 4560, 5, 110, 56, 2, 4560, 4562, 3, 2, 2, 2, 4561, 4483, 3, 2, 2, 2, 4561, 4490, 3, 2, 2, 2, 4561, 4495, 3, 2, 2, 2, 4561, 4502, 3, 2, 2, 2, 4561, 4507, 3, 2, 2, 2, 4561, 4514, 3, 2, 2, 2, 4561, 4523, 3, 2, 2, 2, 4561, 4528, 3, 2, 2, 2, 4561, 4535, 3, 2, 2, 2, 4561, 4540, 3, 2, 2, 2, 4561, 4547, 3, 2, 2, 2, 4561, 4553, 3, 2, 2, 2, 4562, 515, 3, 2, 2, 2, 4563, 4587, 7, 94, 2, 2, 4564, 4587, 7, 321, 2, 2, 4565, 4587, 7, 369, 2, 2, 4566, 4567, 7, 252, 2, 2, 4567, 4587, 7, 369, 2, 2, 4568, 4587, 7, 228, 2, 2, 4569, 4570, 7, 65, 2, 2, 4570, 4587, 7, 94, 2, 2, 4571, 4587, 7, 110, 2, 2, 4572, 4587, 7, 170, 2, 2, 4573, 4587, 7, 335, 2, 2, 4574, 4575, 7, 348, 2, 2, 4575, 4576, 7, 318, 2, 2, 4576, 4587, 7, 276, 2, 2, 4577, 4578, 7, 348, 2, 2, 4578, 4579, 7, 318, 2, 2, 4579, 4587, 7, 187, 2, 2, 4580, 4581, 7, 348, 2, 2, 4581, 4582, 7, 318, 2, 2, 4582, 4587, 7, 346, 2, 2, 4583, 4584, 7, 348, 2, 2, 4584, 4585, 7, 318, 2, 2, 4585, 4587, 7, 165, 2, 2, 4586, 4563, 3, 2, 2, 2, 4586, 4564, 3, 2, 2, 2, 4586, 4565, 3, 2, 2, 2, 4586, 4566, 3, 2, 2, 2, 4586, 4568, 3, 2, 2, 2, 4586, 4569, 3, 2, 2, 2, 4586, 4571, 3, 2, 2, 2, 4586, 4572, 3, 2, 2, 2, 4586, 4573, 3, 2, 2, 2, 4586, 4574, 3, 2, 2, 2, 4586, 4577, 3, 2, 2, 2, 4586, 4580, 3, 2, 2, 2, 4586, 4583, 3, 2, 2, 2, 4587, 517, 3, 2, 2, 2, 4588, 4594, 5, 520, 261, 2, 4589, 4594, 7, 177, 2, 2, 4590, 4594, 7, 311, 2, 2, 4591, 4594, 7, 444, 2, 2, 4592, 4594, 7, 344, 2, 2, 4593, 4588, 3, 2, 2, 2, 4593, 4589, 3, 2, 2, 2, 4593, 4590, 3, 2, 2, 2, 4593, 4591, 3, 2, 2, 2, 4593, 4592, 3, 2, 2, 2, 4594, 519, 3, 2, 2, 2, 4595, 4596, 7, 133, 2, 2, 4596, 4610, 7, 439, 2, 2, 4597, 4598, 7, 200, 2, 2, 4598, 4610, 7, 350, 2, 2, 4599, 4610, 7, 206, 2, 2, 4600, 4601, 7, 65, 2, 2, 4601, 4602, 7, 176, 2, 2, 4602, 4610, 7, 374, 2, 2, 4603, 4604, 5, 310, 156, 2, 4604, 4605, 7, 240, 2, 2, 4605, 4610, 3, 2, 2, 2, 4606, 4610, 7, 445, 2, 2, 4607, 4610, 7, 316, 2, 2, 4608, 4610, 7, 324, 2, 2, 4609, 4595, 3, 2, 2, 2, 4609, 4597, 3, 2, 2, 2, 4609, 4599, 3, 2, 2, 2, 4609, 4600, 3, 2, 2, 2, 4609, 4603, 3, 2, 2, 2, 4609, 4606, 3, 2, 2, 2, 4609, 4607, 3, 2, 2, 2, 4609, 4608, 3, 2, 2, 2, 4610, 521, 3, 2, 2, 2, 4611, 4612, 9, 25, 2, 2, 4612, 523, 3, 2, 2, 2, 4613, 4618, 5, 526, 264, 2, 4614, 4615, 7, 8, 2, 2, 4615, 4617, 5, 526, 264, 2, 4616, 4614, 3, 2, 2, 2, 4617, 4620, 3, 2, 2, 2, 4618, 4616, 3, 2, 2, 2, 4618, 4619, 3, 2, 2, 2, 4619, 525, 3, 2, 2, 2, 4620, 4618, 3, 2, 2, 2, 4621, 4623, 5, 1362, 682, 2, 4622, 4624, 5, 528, 265, 2, 4623, 4622, 3, 2, 2, 2, 4623, 4624, 3, 2, 2, 2, 4624, 527, 3, 2, 2, 2, 4625, 4626, 7, 13, 2, 2, 4626, 4628, 5, 1332, 667, 2, 4627, 4625, 3, 2, 2, 2, 4628, 4629, 3, 2, 2, 2, 4629, 4627, 3, 2, 2, 2, 4629, 4630, 3, 2, 2, 2, 4630, 529, 3, 2, 2, 2, 4631, 4636, 5, 1110, 556, 2, 4632, 4633, 7, 8, 2, 2, 4633, 4635, 5, 1110, 556, 2, 4634, 4632, 3, 2, 2, 2, 4635, 4638, 3, 2, 2, 2, 4636, 4634, 3, 2, 2, 2, 4636, 4637, 3, 2, 2, 2, 4637, 531, 3, 2, 2, 2, 4638, 4636, 3, 2, 2, 2, 4639, 4640, 7, 351, 2, 2, 4640, 4641, 5, 984, 493, 2, 4641, 4642, 5, 1068, 535, 2, 4642, 4643, 5, 534, 268, 2, 4643, 4644, 5, 110, 56, 2, 4644, 533, 3, 2, 2, 2, 4645, 4646, 7, 169, 2, 2, 4646, 4651, 7, 221, 2, 2, 4647, 4648, 7, 307, 2, 2, 4648, 4651, 7, 221, 2, 2, 4649, 4651, 3, 2, 2, 2, 4650, 4645, 3, 2, 2, 2, 4650, 4647, 3, 2, 2, 2, 4650, 4649, 3, 2, 2, 2, 4651, 535, 3, 2, 2, 2, 4652, 4653, 7, 161, 2, 2, 4653, 4654, 7, 82, 2, 2, 4654, 4655, 5, 516, 259, 2, 4655, 4656, 5, 526, 264, 2, 4656, 4657, 7, 118, 2, 2, 4657, 4658, 5, 538, 270, 2, 4658, 4800, 3, 2, 2, 2, 4659, 4660, 7, 161, 2, 2, 4660, 4661, 7, 82, 2, 2, 4661, 4662, 7, 46, 2, 2, 4662, 4663, 5, 526, 264, 2, 4663, 4664, 7, 118, 2, 2, 4664, 4665, 5, 538, 270, 2, 4665, 4800, 3, 2, 2, 2, 4666, 4667, 7, 161, 2, 2, 4667, 4668, 7, 82, 2, 2, 4668, 4669, 5, 518, 260, 2, 4669, 4670, 5, 1330, 666, 2, 4670, 4671, 7, 118, 2, 2, 4671, 4672, 5, 538, 270, 2, 4672, 4800, 3, 2, 2, 2, 4673, 4674, 7, 161, 2, 2, 4674, 4675, 7, 82, 2, 2, 4675, 4676, 7, 353, 2, 2, 4676, 4677, 5, 1110, 556, 2, 4677, 4678, 7, 118, 2, 2, 4678, 4679, 5, 538, 270, 2, 4679, 4800, 3, 2, 2, 2, 4680, 4681, 7, 161, 2, 2, 4681, 4682, 7, 82, 2, 2, 4682, 4683, 7, 191, 2, 2, 4683, 4684, 5, 1110, 556, 2, 4684, 4685, 7, 118, 2, 2, 4685, 4686, 5, 538, 270, 2, 4686, 4800, 3, 2, 2, 2, 4687, 4688, 7, 161, 2, 2, 4688, 4689, 7, 82, 2, 2, 4689, 4690, 7, 138, 2, 2, 4690, 4691, 5, 652, 327, 2, 4691, 4692, 7, 118, 2, 2, 4692, 4693, 5, 538, 270, 2, 4693, 4800, 3, 2, 2, 2, 4694, 4695, 7, 161, 2, 2, 4695, 4696, 7, 82, 2, 2, 4696, 4697, 7, 213, 2, 2, 4697, 4698, 5, 628, 315, 2, 4698, 4699, 7, 118, 2, 2, 4699, 4700, 5, 538, 270, 2, 4700, 4800, 3, 2, 2, 2, 4701, 4702, 7, 161, 2, 2, 4702, 4703, 7, 82, 2, 2, 4703, 4704, 7, 271, 2, 2, 4704, 4705, 5, 690, 346, 2, 4705, 4706, 7, 118, 2, 2, 4706, 4707, 5, 538, 270, 2, 4707, 4800, 3, 2, 2, 2, 4708, 4709, 7, 161, 2, 2, 4709, 4710, 7, 82, 2, 2, 4710, 4711, 7, 47, 2, 2, 4711, 4712, 5, 1330, 666, 2, 4712, 4713, 7, 82, 2, 2, 4713, 4714, 5, 526, 264, 2, 4714, 4715, 7, 118, 2, 2, 4715, 4716, 5, 538, 270, 2, 4716, 4800, 3, 2, 2, 2, 4717, 4718, 7, 161, 2, 2, 4718, 4719, 7, 82, 2, 2, 4719, 4720, 7, 47, 2, 2, 4720, 4721, 5, 1330, 666, 2, 4721, 4722, 7, 82, 2, 2, 4722, 4723, 7, 191, 2, 2, 4723, 4724, 5, 526, 264, 2, 4724, 4725, 7, 118, 2, 2, 4725, 4726, 5, 538, 270, 2, 4726, 4800, 3, 2, 2, 2, 4727, 4728, 7, 161, 2, 2, 4728, 4729, 7, 82, 2, 2, 4729, 4730, 5, 522, 262, 2, 4730, 4731, 5, 1330, 666, 2, 4731, 4732, 7, 82, 2, 2, 4732, 4733, 5, 526, 264, 2, 4733, 4734, 7, 118, 2, 2, 4734, 4735, 5, 538, 270, 2, 4735, 4800, 3, 2, 2, 2, 4736, 4737, 7, 161, 2, 2, 4737, 4738, 7, 82, 2, 2, 4738, 4739, 7, 289, 2, 2, 4739, 4740, 5, 628, 315, 2, 4740, 4741, 7, 118, 2, 2, 4741, 4742, 5, 538, 270, 2, 4742, 4800, 3, 2, 2, 2, 4743, 4744, 7, 161, 2, 2, 4744, 4745, 7, 82, 2, 2, 4745, 4746, 7, 435, 2, 2, 4746, 4747, 5, 628, 315, 2, 4747, 4748, 7, 118, 2, 2, 4748, 4749, 5, 538, 270, 2, 4749, 4800, 3, 2, 2, 2, 4750, 4751, 7, 161, 2, 2, 4751, 4752, 7, 82, 2, 2, 4752, 4753, 7, 436, 2, 2, 4753, 4754, 7, 64, 2, 2, 4754, 4755, 5, 1110, 556, 2, 4755, 4756, 7, 240, 2, 2, 4756, 4757, 5, 1330, 666, 2, 4757, 4758, 7, 118, 2, 2, 4758, 4759, 5, 538, 270, 2, 4759, 4800, 3, 2, 2, 2, 4760, 4761, 7, 161, 2, 2, 4761, 4762, 7, 82, 2, 2, 4762, 4763, 7, 271, 2, 2, 4763, 4764, 7, 158, 2, 2, 4764, 4765, 5, 526, 264, 2, 4765, 4766, 7, 102, 2, 2, 4766, 4767, 5, 1330, 666, 2, 4767, 4768, 7, 118, 2, 2, 4768, 4769, 5, 538, 270, 2, 4769, 4800, 3, 2, 2, 2, 4770, 4771, 7, 161, 2, 2, 4771, 4772, 7, 82, 2, 2, 4772, 4773, 7, 271, 2, 2, 4773, 4774, 7, 208, 2, 2, 4774, 4775, 5, 526, 264, 2, 4775, 4776, 7, 102, 2, 2, 4776, 4777, 5, 1330, 666, 2, 4777, 4778, 7, 118, 2, 2, 4778, 4779, 5, 538, 270, 2, 4779, 4800, 3, 2, 2, 2, 4780, 4781, 7, 161, 2, 2, 4781, 4782, 7, 82, 2, 2, 4782, 4783, 7, 241, 2, 2, 4783, 4784, 7, 267, 2, 2, 4784, 4785, 5, 294, 148, 2, 4785, 4786, 7, 118, 2, 2, 4786, 4787, 5, 538, 270, 2, 4787, 4800, 3, 2, 2, 2, 4788, 4789, 7, 161, 2, 2, 4789, 4790, 7, 82, 2, 2, 4790, 4791, 7, 43, 2, 2, 4791, 4792, 7, 4, 2, 2, 4792, 4793, 5, 1110, 556, 2, 4793, 4794, 7, 38, 2, 2, 4794, 4795, 5, 1110, 556, 2, 4795, 4796, 7, 5, 2, 2, 4796, 4797, 7, 118, 2, 2, 4797, 4798, 5, 538, 270, 2, 4798, 4800, 3, 2, 2, 2, 4799, 4652, 3, 2, 2, 2, 4799, 4659, 3, 2, 2, 2, 4799, 4666, 3, 2, 2, 2, 4799, 4673, 3, 2, 2, 2, 4799, 4680, 3, 2, 2, 2, 4799, 4687, 3, 2, 2, 2, 4799, 4694, 3, 2, 2, 2, 4799, 4701, 3, 2, 2, 2, 4799, 4708, 3, 2, 2, 2, 4799, 4717, 3, 2, 2, 2, 4799, 4727, 3, 2, 2, 2, 4799, 4736, 3, 2, 2, 2, 4799, 4743, 3, 2, 2, 2, 4799, 4750, 3, 2, 2, 2, 4799, 4760, 3, 2, 2, 2, 4799, 4770, 3, 2, 2, 2, 4799, 4780, 3, 2, 2, 2, 4799, 4788, 3, 2, 2, 2, 4800, 537, 3, 2, 2, 2, 4801, 4804, 5, 1348, 675, 2, 4802, 4804, 7, 80, 2, 2, 4803, 4801, 3, 2, 2, 2, 4803, 4802, 3, 2, 2, 2, 4804, 539, 3, 2, 2, 2, 4805, 4806, 7, 320, 2, 2, 4806, 4807, 7, 239, 2, 2, 4807, 4808, 5, 542, 272, 2, 4808, 4809, 7, 82, 2, 2, 4809, 4810, 5, 516, 259, 2, 4810, 4811, 5, 526, 264, 2, 4811, 4812, 7, 118, 2, 2, 4812, 4813, 5, 544, 273, 2, 4813, 4897, 3, 2, 2, 2, 4814, 4815, 7, 320, 2, 2, 4815, 4816, 7, 239, 2, 2, 4816, 4817, 5, 542, 272, 2, 4817, 4818, 7, 82, 2, 2, 4818, 4819, 7, 46, 2, 2, 4819, 4820, 5, 526, 264, 2, 4820, 4821, 7, 118, 2, 2, 4821, 4822, 5, 544, 273, 2, 4822, 4897, 3, 2, 2, 2, 4823, 4824, 7, 320, 2, 2, 4824, 4825, 7, 239, 2, 2, 4825, 4826, 5, 542, 272, 2, 4826, 4827, 7, 82, 2, 2, 4827, 4828, 5, 518, 260, 2, 4828, 4829, 5, 1330, 666, 2, 4829, 4830, 7, 118, 2, 2, 4830, 4831, 5, 544, 273, 2, 4831, 4897, 3, 2, 2, 2, 4832, 4833, 7, 320, 2, 2, 4833, 4834, 7, 239, 2, 2, 4834, 4835, 5, 542, 272, 2, 4835, 4836, 7, 82, 2, 2, 4836, 4837, 7, 353, 2, 2, 4837, 4838, 5, 1110, 556, 2, 4838, 4839, 7, 118, 2, 2, 4839, 4840, 5, 544, 273, 2, 4840, 4897, 3, 2, 2, 2, 4841, 4842, 7, 320, 2, 2, 4842, 4843, 7, 239, 2, 2, 4843, 4844, 5, 542, 272, 2, 4844, 4845, 7, 82, 2, 2, 4845, 4846, 7, 191, 2, 2, 4846, 4847, 5, 1110, 556, 2, 4847, 4848, 7, 118, 2, 2, 4848, 4849, 5, 544, 273, 2, 4849, 4897, 3, 2, 2, 2, 4850, 4851, 7, 320, 2, 2, 4851, 4852, 7, 239, 2, 2, 4852, 4853, 5, 542, 272, 2, 4853, 4854, 7, 82, 2, 2, 4854, 4855, 7, 138, 2, 2, 4855, 4856, 5, 652, 327, 2, 4856, 4857, 7, 118, 2, 2, 4857, 4858, 5, 544, 273, 2, 4858, 4897, 3, 2, 2, 2, 4859, 4860, 7, 320, 2, 2, 4860, 4861, 7, 239, 2, 2, 4861, 4862, 5, 542, 272, 2, 4862, 4863, 7, 82, 2, 2, 4863, 4864, 7, 213, 2, 2, 4864, 4865, 5, 628, 315, 2, 4865, 4866, 7, 118, 2, 2, 4866, 4867, 5, 544, 273, 2, 4867, 4897, 3, 2, 2, 2, 4868, 4869, 7, 320, 2, 2, 4869, 4870, 7, 239, 2, 2, 4870, 4871, 5, 542, 272, 2, 4871, 4872, 7, 82, 2, 2, 4872, 4873, 7, 241, 2, 2, 4873, 4874, 7, 267, 2, 2, 4874, 4875, 5, 294, 148, 2, 4875, 4876, 7, 118, 2, 2, 4876, 4877, 5, 544, 273, 2, 4877, 4897, 3, 2, 2, 2, 4878, 4879, 7, 320, 2, 2, 4879, 4880, 7, 239, 2, 2, 4880, 4881, 5, 542, 272, 2, 4881, 4882, 7, 82, 2, 2, 4882, 4883, 7, 289, 2, 2, 4883, 4884, 5, 628, 315, 2, 4884, 4885, 7, 118, 2, 2, 4885, 4886, 5, 544, 273, 2, 4886, 4897, 3, 2, 2, 2, 4887, 4888, 7, 320, 2, 2, 4888, 4889, 7, 239, 2, 2, 4889, 4890, 5, 542, 272, 2, 4890, 4891, 7, 82, 2, 2, 4891, 4892, 7, 435, 2, 2, 4892, 4893, 5, 628, 315, 2, 4893, 4894, 7, 118, 2, 2, 4894, 4895, 5, 544, 273, 2, 4895, 4897, 3, 2, 2, 2, 4896, 4805, 3, 2, 2, 2, 4896, 4814, 3, 2, 2, 2, 4896, 4823, 3, 2, 2, 2, 4896, 4832, 3, 2, 2, 2, 4896, 4841, 3, 2, 2, 2, 4896, 4850, 3, 2, 2, 2, 4896, 4859, 3, 2, 2, 2, 4896, 4868, 3, 2, 2, 2, 4896, 4878, 3, 2, 2, 2, 4896, 4887, 3, 2, 2, 2, 4897, 541, 3, 2, 2, 2, 4898, 4899, 7, 64, 2, 2, 4899, 4902, 5, 74, 38, 2, 4900, 4902, 3, 2, 2, 2, 4901, 4898, 3, 2, 2, 2, 4901, 4900, 3, 2, 2, 2, 4902, 543, 3, 2, 2, 2, 4903, 4906, 5, 1348, 675, 2, 4904, 4906, 7, 80, 2, 2, 4905, 4903, 3, 2, 2, 2, 4905, 4904, 3, 2, 2, 2, 4906, 545, 3, 2, 2, 2, 4907, 4908, 7, 63, 2, 2, 4908, 4912, 5, 548, 275, 2, 4909, 4910, 7, 258, 2, 2, 4910, 4912, 5, 548, 275, 2, 4911, 4907, 3, 2, 2, 2, 4911, 4909, 3, 2, 2, 2, 4912, 547, 3, 2, 2, 2, 4913, 4980, 5, 948, 475, 2, 4914, 4915, 5, 550, 276, 2, 4915, 4916, 5, 948, 475, 2, 4916, 4980, 3, 2, 2, 2, 4917, 4918, 7, 261, 2, 2, 4918, 4919, 5, 552, 277, 2, 4919, 4920, 5, 948, 475, 2, 4920, 4980, 3, 2, 2, 2, 4921, 4922, 7, 286, 2, 2, 4922, 4923, 5, 552, 277, 2, 4923, 4924, 5, 948, 475, 2, 4924, 4980, 3, 2, 2, 2, 4925, 4926, 7, 209, 2, 2, 4926, 4927, 5, 552, 277, 2, 4927, 4928, 5, 948, 475, 2, 4928, 4980, 3, 2, 2, 2, 4929, 4930, 7, 242, 2, 2, 4930, 4931, 5, 552, 277, 2, 4931, 4932, 5, 948, 475, 2, 4932, 4980, 3, 2, 2, 2, 4933, 4934, 7, 132, 2, 2, 4934, 4935, 5, 1354, 678, 2, 4935, 4936, 5, 552, 277, 2, 4936, 4937, 5, 948, 475, 2, 4937, 4980, 3, 2, 2, 2, 4938, 4939, 7, 300, 2, 2, 4939, 4940, 5, 1354, 678, 2, 4940, 4941, 5, 552, 277, 2, 4941, 4942, 5, 948, 475, 2, 4942, 4980, 3, 2, 2, 2, 4943, 4944, 5, 1354, 678, 2, 4944, 4945, 5, 552, 277, 2, 4945, 4946, 5, 948, 475, 2, 4946, 4980, 3, 2, 2, 2, 4947, 4948, 7, 32, 2, 2, 4948, 4949, 5, 552, 277, 2, 4949, 4950, 5, 948, 475, 2, 4950, 4980, 3, 2, 2, 2, 4951, 4952, 7, 212, 2, 2, 4952, 4953, 5, 552, 277, 2, 4953, 4954, 5, 948, 475, 2, 4954, 4980, 3, 2, 2, 2, 4955, 4956, 7, 212, 2, 2, 4956, 4957, 5, 1354, 678, 2, 4957, 4958, 5, 552, 277, 2, 4958, 4959, 5, 948, 475, 2, 4959, 4980, 3, 2, 2, 2, 4960, 4961, 7, 212, 2, 2, 4961, 4962, 7, 32, 2, 2, 4962, 4963, 5, 552, 277, 2, 4963, 4964, 5, 948, 475, 2, 4964, 4980, 3, 2, 2, 2, 4965, 4966, 7, 146, 2, 2, 4966, 4967, 5, 552, 277, 2, 4967, 4968, 5, 948, 475, 2, 4968, 4980, 3, 2, 2, 2, 4969, 4970, 7, 146, 2, 2, 4970, 4971, 5, 1354, 678, 2, 4971, 4972, 5, 552, 277, 2, 4972, 4973, 5, 948, 475, 2, 4973, 4980, 3, 2, 2, 2, 4974, 4975, 7, 146, 2, 2, 4975, 4976, 7, 32, 2, 2, 4976, 4977, 5, 552, 277, 2, 4977, 4978, 5, 948, 475, 2, 4978, 4980, 3, 2, 2, 2, 4979, 4913, 3, 2, 2, 2, 4979, 4914, 3, 2, 2, 2, 4979, 4917, 3, 2, 2, 2, 4979, 4921, 3, 2, 2, 2, 4979, 4925, 3, 2, 2, 2, 4979, 4929, 3, 2, 2, 2, 4979, 4933, 3, 2, 2, 2, 4979, 4938, 3, 2, 2, 2, 4979, 4943, 3, 2, 2, 2, 4979, 4947, 3, 2, 2, 2, 4979, 4951, 3, 2, 2, 2, 4979, 4955, 3, 2, 2, 2, 4979, 4960, 3, 2, 2, 2, 4979, 4965, 3, 2, 2, 2, 4979, 4969, 3, 2, 2, 2, 4979, 4974, 3, 2, 2, 2, 4980, 549, 3, 2, 2, 2, 4981, 4982, 9, 26, 2, 2, 4982, 551, 3, 2, 2, 2, 4983, 4986, 5, 550, 276, 2, 4984, 4986, 3, 2, 2, 2, 4985, 4983, 3, 2, 2, 2, 4985, 4984, 3, 2, 2, 2, 4986, 553, 3, 2, 2, 2, 4987, 4988, 7, 67, 2, 2, 4988, 4989, 5, 558, 280, 2, 4989, 4990, 7, 82, 2, 2, 4990, 4991, 5, 564, 283, 2, 4991, 4992, 7, 96, 2, 2, 4992, 4993, 5, 566, 284, 2, 4993, 4994, 5, 570, 286, 2, 4994, 555, 3, 2, 2, 2, 4995, 4996, 7, 310, 2, 2, 4996, 4997, 5, 558, 280, 2, 4997, 4998, 7, 82, 2, 2, 4998, 4999, 5, 564, 283, 2, 4999, 5000, 7, 66, 2, 2, 5000, 5001, 5, 566, 284, 2, 5001, 5002, 5, 110, 56, 2, 5002, 5015, 3, 2, 2, 2, 5003, 5004, 7, 310, 2, 2, 5004, 5005, 7, 67, 2, 2, 5005, 5006, 7, 272, 2, 2, 5006, 5007, 7, 64, 2, 2, 5007, 5008, 5, 558, 280, 2, 5008, 5009, 7, 82, 2, 2, 5009, 5010, 5, 564, 283, 2, 5010, 5011, 7, 66, 2, 2, 5011, 5012, 5, 566, 284, 2, 5012, 5013, 5, 110, 56, 2, 5013, 5015, 3, 2, 2, 2, 5014, 4995, 3, 2, 2, 2, 5014, 5003, 3, 2, 2, 2, 5015, 557, 3, 2, 2, 2, 5016, 5032, 5, 560, 281, 2, 5017, 5032, 7, 32, 2, 2, 5018, 5019, 7, 32, 2, 2, 5019, 5032, 7, 287, 2, 2, 5020, 5021, 7, 32, 2, 2, 5021, 5022, 7, 4, 2, 2, 5022, 5023, 5, 218, 110, 2, 5023, 5024, 7, 5, 2, 2, 5024, 5032, 3, 2, 2, 2, 5025, 5026, 7, 32, 2, 2, 5026, 5027, 7, 287, 2, 2, 5027, 5028, 7, 4, 2, 2, 5028, 5029, 5, 218, 110, 2, 5029, 5030, 7, 5, 2, 2, 5030, 5032, 3, 2, 2, 2, 5031, 5016, 3, 2, 2, 2, 5031, 5017, 3, 2, 2, 2, 5031, 5018, 3, 2, 2, 2, 5031, 5020, 3, 2, 2, 2, 5031, 5025, 3, 2, 2, 2, 5032, 559, 3, 2, 2, 2, 5033, 5038, 5, 562, 282, 2, 5034, 5035, 7, 8, 2, 2, 5035, 5037, 5, 562, 282, 2, 5036, 5034, 3, 2, 2, 2, 5037, 5040, 3, 2, 2, 2, 5038, 5036, 3, 2, 2, 2, 5038, 5039, 3, 2, 2, 2, 5039, 561, 3, 2, 2, 2, 5040, 5038, 3, 2, 2, 2, 5041, 5042, 7, 90, 2, 2, 5042, 5051, 5, 216, 109, 2, 5043, 5044, 7, 88, 2, 2, 5044, 5051, 5, 216, 109, 2, 5045, 5046, 7, 48, 2, 2, 5046, 5051, 5, 216, 109, 2, 5047, 5048, 5, 1362, 682, 2, 5048, 5049, 5, 216, 109, 2, 5049, 5051, 3, 2, 2, 2, 5050, 5041, 3, 2, 2, 2, 5050, 5043, 3, 2, 2, 2, 5050, 5045, 3, 2, 2, 2, 5050, 5047, 3, 2, 2, 2, 5051, 563, 3, 2, 2, 2, 5052, 5111, 5, 1324, 663, 2, 5053, 5054, 7, 94, 2, 2, 5054, 5111, 5, 1324, 663, 2, 5055, 5056, 7, 321, 2, 2, 5056, 5111, 5, 1324, 663, 2, 5057, 5058, 7, 65, 2, 2, 5058, 5059, 7, 176, 2, 2, 5059, 5060, 7, 374, 2, 2, 5060, 5111, 5, 1328, 665, 2, 5061, 5062, 7, 65, 2, 2, 5062, 5063, 7, 324, 2, 2, 5063, 5111, 5, 1328, 665, 2, 5064, 5065, 7, 213, 2, 2, 5065, 5111, 5, 626, 314, 2, 5066, 5067, 7, 289, 2, 2, 5067, 5111, 5, 626, 314, 2, 5068, 5069, 7, 435, 2, 2, 5069, 5111, 5, 626, 314, 2, 5070, 5071, 7, 177, 2, 2, 5071, 5111, 5, 1328, 665, 2, 5072, 5073, 7, 191, 2, 2, 5073, 5111, 5, 524, 263, 2, 5074, 5075, 7, 240, 2, 2, 5075, 5111, 5, 1328, 665, 2, 5076, 5077, 7, 241, 2, 2, 5077, 5078, 7, 267, 2, 2, 5078, 5111, 5, 296, 149, 2, 5079, 5080, 7, 316, 2, 2, 5080, 5111, 5, 1328, 665, 2, 5081, 5082, 7, 344, 2, 2, 5082, 5111, 5, 1328, 665, 2, 5083, 5084, 7, 353, 2, 2, 5084, 5111, 5, 524, 263, 2, 5085, 5086, 7, 32, 2, 2, 5086, 5087, 7, 343, 2, 2, 5087, 5088, 7, 70, 2, 2, 5088, 5089, 7, 316, 2, 2, 5089, 5111, 5, 1328, 665, 2, 5090, 5091, 7, 32, 2, 2, 5091, 5092, 7, 322, 2, 2, 5092, 5093, 7, 70, 2, 2, 5093, 5094, 7, 316, 2, 2, 5094, 5111, 5, 1328, 665, 2, 5095, 5096, 7, 32, 2, 2, 5096, 5097, 7, 214, 2, 2, 5097, 5098, 7, 70, 2, 2, 5098, 5099, 7, 316, 2, 2, 5099, 5111, 5, 1328, 665, 2, 5100, 5101, 7, 32, 2, 2, 5101, 5102, 7, 450, 2, 2, 5102, 5103, 7, 70, 2, 2, 5103, 5104, 7, 316, 2, 2, 5104, 5111, 5, 1328, 665, 2, 5105, 5106, 7, 32, 2, 2, 5106, 5107, 7, 448, 2, 2, 5107, 5108, 7, 70, 2, 2, 5108, 5109, 7, 316, 2, 2, 5109, 5111, 5, 1328, 665, 2, 5110, 5052, 3, 2, 2, 2, 5110, 5053, 3, 2, 2, 2, 5110, 5055, 3, 2, 2, 2, 5110, 5057, 3, 2, 2, 2, 5110, 5061, 3, 2, 2, 2, 5110, 5064, 3, 2, 2, 2, 5110, 5066, 3, 2, 2, 2, 5110, 5068, 3, 2, 2, 2, 5110, 5070, 3, 2, 2, 2, 5110, 5072, 3, 2, 2, 2, 5110, 5074, 3, 2, 2, 2, 5110, 5076, 3, 2, 2, 2, 5110, 5079, 3, 2, 2, 2, 5110, 5081, 3, 2, 2, 2, 5110, 5083, 3, 2, 2, 2, 5110, 5085, 3, 2, 2, 2, 5110, 5090, 3, 2, 2, 2, 5110, 5095, 3, 2, 2, 2, 5110, 5100, 3, 2, 2, 2, 5110, 5105, 3, 2, 2, 2, 5111, 565, 3, 2, 2, 2, 5112, 5117, 5, 568, 285, 2, 5113, 5114, 7, 8, 2, 2, 5114, 5116, 5, 568, 285, 2, 5115, 5113, 3, 2, 2, 2, 5116, 5119, 3, 2, 2, 2, 5117, 5115, 3, 2, 2, 2, 5117, 5118, 3, 2, 2, 2, 5118, 567, 3, 2, 2, 2, 5119, 5117, 3, 2, 2, 2, 5120, 5124, 5, 1358, 680, 2, 5121, 5122, 7, 68, 2, 2, 5122, 5124, 5, 1358, 680, 2, 5123, 5120, 3, 2, 2, 2, 5123, 5121, 3, 2, 2, 2, 5124, 569, 3, 2, 2, 2, 5125, 5126, 7, 107, 2, 2, 5126, 5127, 7, 67, 2, 2, 5127, 5130, 7, 272, 2, 2, 5128, 5130, 3, 2, 2, 2, 5129, 5125, 3, 2, 2, 2, 5129, 5128, 3, 2, 2, 2, 5130, 571, 3, 2, 2, 2, 5131, 5132, 7, 67, 2, 2, 5132, 5133, 5, 560, 281, 2, 5133, 5134, 7, 96, 2, 2, 5134, 5135, 5, 1360, 681, 2, 5135, 5136, 5, 576, 289, 2, 5136, 5137, 5, 578, 290, 2, 5137, 573, 3, 2, 2, 2, 5138, 5139, 7, 310, 2, 2, 5139, 5140, 5, 560, 281, 2, 5140, 5141, 7, 66, 2, 2, 5141, 5142, 5, 1360, 681, 2, 5142, 5143, 5, 578, 290, 2, 5143, 5144, 5, 110, 56, 2, 5144, 5156, 3, 2, 2, 2, 5145, 5146, 7, 310, 2, 2, 5146, 5147, 7, 136, 2, 2, 5147, 5148, 7, 272, 2, 2, 5148, 5149, 7, 64, 2, 2, 5149, 5150, 5, 560, 281, 2, 5150, 5151, 7, 66, 2, 2, 5151, 5152, 5, 1360, 681, 2, 5152, 5153, 5, 578, 290, 2, 5153, 5154, 5, 110, 56, 2, 5154, 5156, 3, 2, 2, 2, 5155, 5138, 3, 2, 2, 2, 5155, 5145, 3, 2, 2, 2, 5156, 575, 3, 2, 2, 2, 5157, 5158, 7, 107, 2, 2, 5158, 5159, 7, 136, 2, 2, 5159, 5162, 7, 272, 2, 2, 5160, 5162, 3, 2, 2, 2, 5161, 5157, 3, 2, 2, 2, 5161, 5160, 3, 2, 2, 2, 5162, 577, 3, 2, 2, 2, 5163, 5164, 7, 216, 2, 2, 5164, 5165, 7, 149, 2, 2, 5165, 5168, 5, 1358, 680, 2, 5166, 5168, 3, 2, 2, 2, 5167, 5163, 3, 2, 2, 2, 5167, 5166, 3, 2, 2, 2, 5168, 579, 3, 2, 2, 2, 5169, 5170, 7, 140, 2, 2, 5170, 5171, 7, 55, 2, 2, 5171, 5172, 7, 287, 2, 2, 5172, 5173, 5, 582, 292, 2, 5173, 5174, 5, 586, 294, 2, 5174, 581, 3, 2, 2, 2, 5175, 5177, 5, 584, 293, 2, 5176, 5175, 3, 2, 2, 2, 5177, 5180, 3, 2, 2, 2, 5178, 5176, 3, 2, 2, 2, 5178, 5179, 3, 2, 2, 2, 5179, 583, 3, 2, 2, 2, 5180, 5178, 3, 2, 2, 2, 5181, 5182, 7, 70, 2, 2, 5182, 5183, 7, 316, 2, 2, 5183, 5191, 5, 1328, 665, 2, 5184, 5185, 7, 64, 2, 2, 5185, 5186, 7, 311, 2, 2, 5186, 5191, 5, 1360, 681, 2, 5187, 5188, 7, 64, 2, 2, 5188, 5189, 7, 101, 2, 2, 5189, 5191, 5, 1360, 681, 2, 5190, 5181, 3, 2, 2, 2, 5190, 5184, 3, 2, 2, 2, 5190, 5187, 3, 2, 2, 2, 5191, 585, 3, 2, 2, 2, 5192, 5193, 7, 67, 2, 2, 5193, 5194, 5, 558, 280, 2, 5194, 5195, 7, 82, 2, 2, 5195, 5196, 5, 588, 295, 2, 5196, 5197, 7, 96, 2, 2, 5197, 5198, 5, 566, 284, 2, 5198, 5199, 5, 570, 286, 2, 5199, 5220, 3, 2, 2, 2, 5200, 5201, 7, 310, 2, 2, 5201, 5202, 5, 558, 280, 2, 5202, 5203, 7, 82, 2, 2, 5203, 5204, 5, 588, 295, 2, 5204, 5205, 7, 66, 2, 2, 5205, 5206, 5, 566, 284, 2, 5206, 5207, 5, 110, 56, 2, 5207, 5220, 3, 2, 2, 2, 5208, 5209, 7, 310, 2, 2, 5209, 5210, 7, 67, 2, 2, 5210, 5211, 7, 272, 2, 2, 5211, 5212, 7, 64, 2, 2, 5212, 5213, 5, 558, 280, 2, 5213, 5214, 7, 82, 2, 2, 5214, 5215, 5, 588, 295, 2, 5215, 5216, 7, 66, 2, 2, 5216, 5217, 5, 566, 284, 2, 5217, 5218, 5, 110, 56, 2, 5218, 5220, 3, 2, 2, 2, 5219, 5192, 3, 2, 2, 2, 5219, 5200, 3, 2, 2, 2, 5219, 5208, 3, 2, 2, 2, 5220, 587, 3, 2, 2, 2, 5221, 5222, 9, 27, 2, 2, 5222, 589, 3, 2, 2, 2, 5223, 5224, 7, 48, 2, 2, 5224, 5225, 5, 592, 297, 2, 5225, 5226, 7, 228, 2, 2, 5226, 5227, 5, 594, 298, 2, 5227, 5228, 5, 596, 299, 2, 5228, 5229, 7, 82, 2, 2, 5229, 5230, 5, 1066, 534, 2, 5230, 5231, 5, 598, 300, 2, 5231, 5232, 7, 4, 2, 2, 5232, 5233, 5, 600, 301, 2, 5233, 5234, 7, 5, 2, 2, 5234, 5235, 5, 606, 304, 2, 5235, 5236, 5, 120, 61, 2, 5236, 5237, 5, 256, 129, 2, 5237, 5238, 5, 1086, 544, 2, 5238, 5259, 3, 2, 2, 2, 5239, 5240, 7, 48, 2, 2, 5240, 5241, 5, 592, 297, 2, 5241, 5242, 7, 228, 2, 2, 5242, 5243, 5, 594, 298, 2, 5243, 5244, 7, 222, 2, 2, 5244, 5245, 7, 79, 2, 2, 5245, 5246, 7, 389, 2, 2, 5246, 5247, 5, 1330, 666, 2, 5247, 5248, 7, 82, 2, 2, 5248, 5249, 5, 1066, 534, 2, 5249, 5250, 5, 598, 300, 2, 5250, 5251, 7, 4, 2, 2, 5251, 5252, 5, 600, 301, 2, 5252, 5253, 7, 5, 2, 2, 5253, 5254, 5, 606, 304, 2, 5254, 5255, 5, 120, 61, 2, 5255, 5256, 5, 256, 129, 2, 5256, 5257, 5, 1086, 544, 2, 5257, 5259, 3, 2, 2, 2, 5258, 5223, 3, 2, 2, 2, 5258, 5239, 3, 2, 2, 2, 5259, 591, 3, 2, 2, 2, 5260, 5263, 7, 100, 2, 2, 5261, 5263, 3, 2, 2, 2, 5262, 5260, 3, 2, 2, 2, 5262, 5261, 3, 2, 2, 2, 5263, 593, 3, 2, 2, 2, 5264, 5267, 7, 111, 2, 2, 5265, 5267, 3, 2, 2, 2, 5266, 5264, 3, 2, 2, 2, 5266, 5265, 3, 2, 2, 2, 5267, 595, 3, 2, 2, 2, 5268, 5271, 5, 1330, 666, 2, 5269, 5271, 3, 2, 2, 2, 5270, 5268, 3, 2, 2, 2, 5270, 5269, 3, 2, 2, 2, 5271, 597, 3, 2, 2, 2, 5272, 5273, 7, 102, 2, 2, 5273, 5276, 5, 1330, 666, 2, 5274, 5276, 3, 2, 2, 2, 5275, 5272, 3, 2, 2, 2, 5275, 5274, 3, 2, 2, 2, 5276, 599, 3, 2, 2, 2, 5277, 5282, 5, 604, 303, 2, 5278, 5279, 7, 8, 2, 2, 5279, 5281, 5, 604, 303, 2, 5280, 5278, 3, 2, 2, 2, 5281, 5284, 3, 2, 2, 2, 5282, 5280, 3, 2, 2, 2, 5282, 5283, 3, 2, 2, 2, 5283, 601, 3, 2, 2, 2, 5284, 5282, 3, 2, 2, 2, 5285, 5286, 5, 610, 306, 2, 5286, 5287, 5, 612, 307, 2, 5287, 5288, 5, 614, 308, 2, 5288, 5289, 5, 616, 309, 2, 5289, 5297, 3, 2, 2, 2, 5290, 5291, 5, 610, 306, 2, 5291, 5292, 5, 526, 264, 2, 5292, 5293, 5, 118, 60, 2, 5293, 5294, 5, 614, 308, 2, 5294, 5295, 5, 616, 309, 2, 5295, 5297, 3, 2, 2, 2, 5296, 5285, 3, 2, 2, 2, 5296, 5290, 3, 2, 2, 2, 5297, 603, 3, 2, 2, 2, 5298, 5299, 5, 1362, 682, 2, 5299, 5300, 5, 602, 302, 2, 5300, 5310, 3, 2, 2, 2, 5301, 5302, 5, 1204, 603, 2, 5302, 5303, 5, 602, 302, 2, 5303, 5310, 3, 2, 2, 2, 5304, 5305, 7, 4, 2, 2, 5305, 5306, 5, 1154, 578, 2, 5306, 5307, 7, 5, 2, 2, 5307, 5308, 5, 602, 302, 2, 5308, 5310, 3, 2, 2, 2, 5309, 5298, 3, 2, 2, 2, 5309, 5301, 3, 2, 2, 2, 5309, 5304, 3, 2, 2, 2, 5310, 605, 3, 2, 2, 2, 5311, 5312, 7, 434, 2, 2, 5312, 5313, 7, 4, 2, 2, 5313, 5314, 5, 608, 305, 2, 5314, 5315, 7, 5, 2, 2, 5315, 5318, 3, 2, 2, 2, 5316, 5318, 3, 2, 2, 2, 5317, 5311, 3, 2, 2, 2, 5317, 5316, 3, 2, 2, 2, 5318, 607, 3, 2, 2, 2, 5319, 5324, 5, 604, 303, 2, 5320, 5321, 7, 8, 2, 2, 5321, 5323, 5, 604, 303, 2, 5322, 5320, 3, 2, 2, 2, 5323, 5326, 3, 2, 2, 2, 5324, 5322, 3, 2, 2, 2, 5324, 5325, 3, 2, 2, 2, 5325, 609, 3, 2, 2, 2, 5326, 5324, 3, 2, 2, 2, 5327, 5328, 7, 45, 2, 2, 5328, 5331, 5, 526, 264, 2, 5329, 5331, 3, 2, 2, 2, 5330, 5327, 3, 2, 2, 2, 5330, 5329, 3, 2, 2, 2, 5331, 611, 3, 2, 2, 2, 5332, 5335, 5, 526, 264, 2, 5333, 5335, 3, 2, 2, 2, 5334, 5332, 3, 2, 2, 2, 5334, 5333, 3, 2, 2, 2, 5335, 613, 3, 2, 2, 2, 5336, 5340, 7, 39, 2, 2, 5337, 5340, 7, 57, 2, 2, 5338, 5340, 3, 2, 2, 2, 5339, 5336, 3, 2, 2, 2, 5339, 5337, 3, 2, 2, 2, 5339, 5338, 3, 2, 2, 2, 5340, 615, 3, 2, 2, 2, 5341, 5342, 7, 266, 2, 2, 5342, 5347, 7, 209, 2, 2, 5343, 5344, 7, 266, 2, 2, 5344, 5347, 7, 242, 2, 2, 5345, 5347, 3, 2, 2, 2, 5346, 5341, 3, 2, 2, 2, 5346, 5343, 3, 2, 2, 2, 5346, 5345, 3, 2, 2, 2, 5347, 617, 3, 2, 2, 2, 5348, 5349, 7, 48, 2, 2, 5349, 5350, 5, 620, 311, 2, 5350, 5351, 9, 24, 2, 2, 5351, 5352, 5, 1336, 669, 2, 5352, 5362, 5, 630, 316, 2, 5353, 5360, 7, 309, 2, 2, 5354, 5361, 5, 640, 321, 2, 5355, 5356, 7, 94, 2, 2, 5356, 5357, 7, 4, 2, 2, 5357, 5358, 5, 670, 336, 2, 5358, 5359, 7, 5, 2, 2, 5359, 5361, 3, 2, 2, 2, 5360, 5354, 3, 2, 2, 2, 5360, 5355, 3, 2, 2, 2, 5361, 5363, 3, 2, 2, 2, 5362, 5353, 3, 2, 2, 2, 5362, 5363, 3, 2, 2, 2, 5363, 5364, 3, 2, 2, 2, 5364, 5365, 5, 656, 329, 2, 5365, 619, 3, 2, 2, 2, 5366, 5367, 7, 84, 2, 2, 5367, 5370, 7, 304, 2, 2, 5368, 5370, 3, 2, 2, 2, 5369, 5366, 3, 2, 2, 2, 5369, 5368, 3, 2, 2, 2, 5370, 621, 3, 2, 2, 2, 5371, 5373, 7, 4, 2, 2, 5372, 5374, 5, 624, 313, 2, 5373, 5372, 3, 2, 2, 2, 5373, 5374, 3, 2, 2, 2, 5374, 5375, 3, 2, 2, 2, 5375, 5376, 7, 5, 2, 2, 5376, 623, 3, 2, 2, 2, 5377, 5382, 5, 634, 318, 2, 5378, 5379, 7, 8, 2, 2, 5379, 5381, 5, 634, 318, 2, 5380, 5378, 3, 2, 2, 2, 5381, 5384, 3, 2, 2, 2, 5382, 5380, 3, 2, 2, 2, 5382, 5383, 3, 2, 2, 2, 5383, 625, 3, 2, 2, 2, 5384, 5382, 3, 2, 2, 2, 5385, 5390, 5, 628, 315, 2, 5386, 5387, 7, 8, 2, 2, 5387, 5389, 5, 628, 315, 2, 5388, 5386, 3, 2, 2, 2, 5389, 5392, 3, 2, 2, 2, 5390, 5388, 3, 2, 2, 2, 5390, 5391, 3, 2, 2, 2, 5391, 627, 3, 2, 2, 2, 5392, 5390, 3, 2, 2, 2, 5393, 5394, 5, 1336, 669, 2, 5394, 5395, 5, 622, 312, 2, 5395, 5402, 3, 2, 2, 2, 5396, 5402, 5, 1378, 690, 2, 5397, 5399, 5, 1362, 682, 2, 5398, 5400, 5, 1314, 658, 2, 5399, 5398, 3, 2, 2, 2, 5399, 5400, 3, 2, 2, 2, 5400, 5402, 3, 2, 2, 2, 5401, 5393, 3, 2, 2, 2, 5401, 5396, 3, 2, 2, 2, 5401, 5397, 3, 2, 2, 2, 5402, 629, 3, 2, 2, 2, 5403, 5405, 7, 4, 2, 2, 5404, 5406, 5, 632, 317, 2, 5405, 5404, 3, 2, 2, 2, 5405, 5406, 3, 2, 2, 2, 5406, 5407, 3, 2, 2, 2, 5407, 5408, 7, 5, 2, 2, 5408, 631, 3, 2, 2, 2, 5409, 5414, 5, 644, 323, 2, 5410, 5411, 7, 8, 2, 2, 5411, 5413, 5, 644, 323, 2, 5412, 5410, 3, 2, 2, 2, 5413, 5416, 3, 2, 2, 2, 5414, 5412, 3, 2, 2, 2, 5414, 5415, 3, 2, 2, 2, 5415, 633, 3, 2, 2, 2, 5416, 5414, 3, 2, 2, 2, 5417, 5419, 5, 636, 319, 2, 5418, 5420, 5, 638, 320, 2, 5419, 5418, 3, 2, 2, 2, 5419, 5420, 3, 2, 2, 2, 5420, 5421, 3, 2, 2, 2, 5421, 5422, 5, 642, 322, 2, 5422, 5431, 3, 2, 2, 2, 5423, 5425, 5, 638, 320, 2, 5424, 5426, 5, 636, 319, 2, 5425, 5424, 3, 2, 2, 2, 5425, 5426, 3, 2, 2, 2, 5426, 5427, 3, 2, 2, 2, 5427, 5428, 5, 642, 322, 2, 5428, 5431, 3, 2, 2, 2, 5429, 5431, 5, 642, 322, 2, 5430, 5417, 3, 2, 2, 2, 5430, 5423, 3, 2, 2, 2, 5430, 5429, 3, 2, 2, 2, 5431, 635, 3, 2, 2, 2, 5432, 5434, 7, 70, 2, 2, 5433, 5435, 7, 446, 2, 2, 5434, 5433, 3, 2, 2, 2, 5434, 5435, 3, 2, 2, 2, 5435, 5440, 3, 2, 2, 2, 5436, 5440, 7, 446, 2, 2, 5437, 5440, 7, 393, 2, 2, 5438, 5440, 7, 103, 2, 2, 5439, 5432, 3, 2, 2, 2, 5439, 5436, 3, 2, 2, 2, 5439, 5437, 3, 2, 2, 2, 5439, 5438, 3, 2, 2, 2, 5440, 637, 3, 2, 2, 2, 5441, 5442, 5, 1364, 683, 2, 5442, 639, 3, 2, 2, 2, 5443, 5444, 5, 642, 322, 2, 5444, 641, 3, 2, 2, 2, 5445, 5458, 5, 1110, 556, 2, 5446, 5447, 5, 1364, 683, 2, 5447, 5448, 5, 528, 265, 2, 5448, 5449, 7, 29, 2, 2, 5449, 5450, 7, 353, 2, 2, 5450, 5458, 3, 2, 2, 2, 5451, 5452, 7, 408, 2, 2, 5452, 5453, 5, 1364, 683, 2, 5453, 5454, 5, 528, 265, 2, 5454, 5455, 7, 29, 2, 2, 5455, 5456, 7, 353, 2, 2, 5456, 5458, 3, 2, 2, 2, 5457, 5445, 3, 2, 2, 2, 5457, 5446, 3, 2, 2, 2, 5457, 5451, 3, 2, 2, 2, 5458, 643, 3, 2, 2, 2, 5459, 5462, 5, 634, 318, 2, 5460, 5461, 9, 28, 2, 2, 5461, 5463, 5, 1154, 578, 2, 5462, 5460, 3, 2, 2, 2, 5462, 5463, 3, 2, 2, 2, 5463, 645, 3, 2, 2, 2, 5464, 5465, 5, 634, 318, 2, 5465, 647, 3, 2, 2, 2, 5466, 5477, 7, 4, 2, 2, 5467, 5478, 7, 11, 2, 2, 5468, 5478, 5, 650, 326, 2, 5469, 5470, 7, 85, 2, 2, 5470, 5471, 7, 149, 2, 2, 5471, 5478, 5, 650, 326, 2, 5472, 5473, 5, 650, 326, 2, 5473, 5474, 7, 85, 2, 2, 5474, 5475, 7, 149, 2, 2, 5475, 5476, 5, 650, 326, 2, 5476, 5478, 3, 2, 2, 2, 5477, 5467, 3, 2, 2, 2, 5477, 5468, 3, 2, 2, 2, 5477, 5469, 3, 2, 2, 2, 5477, 5472, 3, 2, 2, 2, 5478, 5479, 3, 2, 2, 2, 5479, 5480, 7, 5, 2, 2, 5480, 649, 3, 2, 2, 2, 5481, 5486, 5, 646, 324, 2, 5482, 5483, 7, 8, 2, 2, 5483, 5485, 5, 646, 324, 2, 5484, 5482, 3, 2, 2, 2, 5485, 5488, 3, 2, 2, 2, 5486, 5484, 3, 2, 2, 2, 5486, 5487, 3, 2, 2, 2, 5487, 651, 3, 2, 2, 2, 5488, 5486, 3, 2, 2, 2, 5489, 5490, 5, 1336, 669, 2, 5490, 5491, 5, 648, 325, 2, 5491, 653, 3, 2, 2, 2, 5492, 5497, 5, 652, 327, 2, 5493, 5494, 7, 8, 2, 2, 5494, 5496, 5, 652, 327, 2, 5495, 5493, 3, 2, 2, 2, 5496, 5499, 3, 2, 2, 2, 5497, 5495, 3, 2, 2, 2, 5497, 5498, 3, 2, 2, 2, 5498, 655, 3, 2, 2, 2, 5499, 5497, 3, 2, 2, 2, 5500, 5502, 5, 660, 331, 2, 5501, 5500, 3, 2, 2, 2, 5502, 5503, 3, 2, 2, 2, 5503, 5501, 3, 2, 2, 2, 5503, 5504, 3, 2, 2, 2, 5504, 5505, 3, 2, 2, 2, 5505, 5506, 8, 329, 1, 2, 5506, 657, 3, 2, 2, 2, 5507, 5508, 7, 151, 2, 2, 5508, 5509, 7, 82, 2, 2, 5509, 5510, 7, 80, 2, 2, 5510, 5543, 7, 451, 2, 2, 5511, 5512, 7, 309, 2, 2, 5512, 5513, 7, 80, 2, 2, 5513, 5514, 7, 82, 2, 2, 5514, 5515, 7, 80, 2, 2, 5515, 5543, 7, 451, 2, 2, 5516, 5543, 7, 339, 2, 2, 5517, 5543, 7, 224, 2, 2, 5518, 5543, 7, 331, 2, 2, 5519, 5543, 7, 370, 2, 2, 5520, 5521, 7, 207, 2, 2, 5521, 5522, 7, 320, 2, 2, 5522, 5543, 7, 183, 2, 2, 5523, 5524, 7, 207, 2, 2, 5524, 5525, 7, 320, 2, 2, 5525, 5543, 7, 236, 2, 2, 5526, 5527, 7, 320, 2, 2, 5527, 5543, 7, 183, 2, 2, 5528, 5529, 7, 320, 2, 2, 5529, 5543, 7, 236, 2, 2, 5530, 5543, 7, 243, 2, 2, 5531, 5532, 7, 79, 2, 2, 5532, 5543, 7, 243, 2, 2, 5533, 5534, 7, 172, 2, 2, 5534, 5543, 5, 294, 148, 2, 5535, 5536, 7, 313, 2, 2, 5536, 5543, 5, 294, 148, 2, 5537, 5538, 7, 452, 2, 2, 5538, 5543, 5, 526, 264, 2, 5539, 5543, 5, 84, 43, 2, 5540, 5541, 7, 453, 2, 2, 5541, 5543, 5, 1362, 682, 2, 5542, 5507, 3, 2, 2, 2, 5542, 5511, 3, 2, 2, 2, 5542, 5516, 3, 2, 2, 2, 5542, 5517, 3, 2, 2, 2, 5542, 5518, 3, 2, 2, 2, 5542, 5519, 3, 2, 2, 2, 5542, 5520, 3, 2, 2, 2, 5542, 5523, 3, 2, 2, 2, 5542, 5526, 3, 2, 2, 2, 5542, 5528, 3, 2, 2, 2, 5542, 5530, 3, 2, 2, 2, 5542, 5531, 3, 2, 2, 2, 5542, 5533, 3, 2, 2, 2, 5542, 5535, 3, 2, 2, 2, 5542, 5537, 3, 2, 2, 2, 5542, 5539, 3, 2, 2, 2, 5542, 5540, 3, 2, 2, 2, 5543, 659, 3, 2, 2, 2, 5544, 5545, 7, 38, 2, 2, 5545, 5553, 5, 662, 332, 2, 5546, 5547, 7, 240, 2, 2, 5547, 5553, 5, 74, 38, 2, 5548, 5549, 7, 436, 2, 2, 5549, 5553, 5, 664, 333, 2, 5550, 5553, 7, 106, 2, 2, 5551, 5553, 5, 658, 330, 2, 5552, 5544, 3, 2, 2, 2, 5552, 5546, 3, 2, 2, 2, 5552, 5548, 3, 2, 2, 2, 5552, 5550, 3, 2, 2, 2, 5552, 5551, 3, 2, 2, 2, 5553, 661, 3, 2, 2, 2, 5554, 5560, 5, 1348, 675, 2, 5555, 5556, 5, 1348, 675, 2, 5556, 5557, 7, 8, 2, 2, 5557, 5558, 5, 1348, 675, 2, 5558, 5560, 3, 2, 2, 2, 5559, 5554, 3, 2, 2, 2, 5559, 5555, 3, 2, 2, 2, 5560, 663, 3, 2, 2, 2, 5561, 5562, 7, 64, 2, 2, 5562, 5563, 7, 353, 2, 2, 5563, 5570, 5, 1110, 556, 2, 5564, 5565, 7, 8, 2, 2, 5565, 5566, 7, 64, 2, 2, 5566, 5567, 7, 353, 2, 2, 5567, 5569, 5, 1110, 556, 2, 5568, 5564, 3, 2, 2, 2, 5569, 5572, 3, 2, 2, 2, 5570, 5568, 3, 2, 2, 2, 5570, 5571, 3, 2, 2, 2, 5571, 665, 3, 2, 2, 2, 5572, 5570, 3, 2, 2, 2, 5573, 5574, 7, 107, 2, 2, 5574, 5577, 5, 462, 232, 2, 5575, 5577, 3, 2, 2, 2, 5576, 5573, 3, 2, 2, 2, 5576, 5575, 3, 2, 2, 2, 5577, 667, 3, 2, 2, 2, 5578, 5579, 5, 638, 320, 2, 5579, 5580, 5, 642, 322, 2, 5580, 669, 3, 2, 2, 2, 5581, 5586, 5, 668, 335, 2, 5582, 5583, 7, 8, 2, 2, 5583, 5585, 5, 668, 335, 2, 5584, 5582, 3, 2, 2, 2, 5585, 5588, 3, 2, 2, 2, 5586, 5584, 3, 2, 2, 2, 5586, 5587, 3, 2, 2, 2, 5587, 671, 3, 2, 2, 2, 5588, 5586, 3, 2, 2, 2, 5589, 5590, 7, 140, 2, 2, 5590, 5591, 9, 29, 2, 2, 5591, 5592, 5, 628, 315, 2, 5592, 5593, 5, 674, 338, 2, 5593, 5594, 5, 676, 339, 2, 5594, 673, 3, 2, 2, 2, 5595, 5597, 5, 658, 330, 2, 5596, 5595, 3, 2, 2, 2, 5597, 5598, 3, 2, 2, 2, 5598, 5596, 3, 2, 2, 2, 5598, 5599, 3, 2, 2, 2, 5599, 675, 3, 2, 2, 2, 5600, 5603, 7, 308, 2, 2, 5601, 5603, 3, 2, 2, 2, 5602, 5600, 3, 2, 2, 2, 5602, 5601, 3, 2, 2, 2, 5603, 677, 3, 2, 2, 2, 5604, 5605, 7, 193, 2, 2, 5605, 5606, 7, 213, 2, 2, 5606, 5607, 5, 626, 314, 2, 5607, 5608, 5, 110, 56, 2, 5608, 5641, 3, 2, 2, 2, 5609, 5610, 7, 193, 2, 2, 5610, 5611, 7, 213, 2, 2, 5611, 5612, 7, 222, 2, 2, 5612, 5613, 7, 389, 2, 2, 5613, 5614, 5, 626, 314, 2, 5614, 5615, 5, 110, 56, 2, 5615, 5641, 3, 2, 2, 2, 5616, 5617, 7, 193, 2, 2, 5617, 5618, 7, 289, 2, 2, 5618, 5619, 5, 626, 314, 2, 5619, 5620, 5, 110, 56, 2, 5620, 5641, 3, 2, 2, 2, 5621, 5622, 7, 193, 2, 2, 5622, 5623, 7, 289, 2, 2, 5623, 5624, 7, 222, 2, 2, 5624, 5625, 7, 389, 2, 2, 5625, 5626, 5, 626, 314, 2, 5626, 5627, 5, 110, 56, 2, 5627, 5641, 3, 2, 2, 2, 5628, 5629, 7, 193, 2, 2, 5629, 5630, 7, 435, 2, 2, 5630, 5631, 5, 626, 314, 2, 5631, 5632, 5, 110, 56, 2, 5632, 5641, 3, 2, 2, 2, 5633, 5634, 7, 193, 2, 2, 5634, 5635, 7, 435, 2, 2, 5635, 5636, 7, 222, 2, 2, 5636, 5637, 7, 389, 2, 2, 5637, 5638, 5, 626, 314, 2, 5638, 5639, 5, 110, 56, 2, 5639, 5641, 3, 2, 2, 2, 5640, 5604, 3, 2, 2, 2, 5640, 5609, 3, 2, 2, 2, 5640, 5616, 3, 2, 2, 2, 5640, 5621, 3, 2, 2, 2, 5640, 5628, 3, 2, 2, 2, 5640, 5633, 3, 2, 2, 2, 5641, 679, 3, 2, 2, 2, 5642, 5643, 7, 193, 2, 2, 5643, 5644, 7, 138, 2, 2, 5644, 5645, 5, 654, 328, 2, 5645, 5646, 5, 110, 56, 2, 5646, 5655, 3, 2, 2, 2, 5647, 5648, 7, 193, 2, 2, 5648, 5649, 7, 138, 2, 2, 5649, 5650, 7, 222, 2, 2, 5650, 5651, 7, 389, 2, 2, 5651, 5652, 5, 654, 328, 2, 5652, 5653, 5, 110, 56, 2, 5653, 5655, 3, 2, 2, 2, 5654, 5642, 3, 2, 2, 2, 5654, 5647, 3, 2, 2, 2, 5655, 681, 3, 2, 2, 2, 5656, 5657, 7, 193, 2, 2, 5657, 5658, 7, 271, 2, 2, 5658, 5659, 5, 688, 345, 2, 5659, 5660, 5, 110, 56, 2, 5660, 5669, 3, 2, 2, 2, 5661, 5662, 7, 193, 2, 2, 5662, 5663, 7, 271, 2, 2, 5663, 5664, 7, 222, 2, 2, 5664, 5665, 7, 389, 2, 2, 5665, 5666, 5, 688, 345, 2, 5666, 5667, 5, 110, 56, 2, 5667, 5669, 3, 2, 2, 2, 5668, 5656, 3, 2, 2, 2, 5668, 5661, 3, 2, 2, 2, 5669, 683, 3, 2, 2, 2, 5670, 5671, 7, 4, 2, 2, 5671, 5672, 5, 1110, 556, 2, 5672, 5673, 7, 5, 2, 2, 5673, 5693, 3, 2, 2, 2, 5674, 5675, 7, 4, 2, 2, 5675, 5676, 5, 1110, 556, 2, 5676, 5677, 7, 8, 2, 2, 5677, 5678, 5, 1110, 556, 2, 5678, 5679, 7, 5, 2, 2, 5679, 5693, 3, 2, 2, 2, 5680, 5681, 7, 4, 2, 2, 5681, 5682, 7, 400, 2, 2, 5682, 5683, 7, 8, 2, 2, 5683, 5684, 5, 1110, 556, 2, 5684, 5685, 7, 5, 2, 2, 5685, 5693, 3, 2, 2, 2, 5686, 5687, 7, 4, 2, 2, 5687, 5688, 5, 1110, 556, 2, 5688, 5689, 7, 8, 2, 2, 5689, 5690, 7, 400, 2, 2, 5690, 5691, 7, 5, 2, 2, 5691, 5693, 3, 2, 2, 2, 5692, 5670, 3, 2, 2, 2, 5692, 5674, 3, 2, 2, 2, 5692, 5680, 3, 2, 2, 2, 5692, 5686, 3, 2, 2, 2, 5693, 685, 3, 2, 2, 2, 5694, 5695, 5, 1362, 682, 2, 5695, 5696, 7, 13, 2, 2, 5696, 5698, 3, 2, 2, 2, 5697, 5694, 3, 2, 2, 2, 5698, 5701, 3, 2, 2, 2, 5699, 5697, 3, 2, 2, 2, 5699, 5700, 3, 2, 2, 2, 5700, 5702, 3, 2, 2, 2, 5701, 5699, 3, 2, 2, 2, 5702, 5703, 5, 1260, 631, 2, 5703, 687, 3, 2, 2, 2, 5704, 5709, 5, 690, 346, 2, 5705, 5706, 7, 8, 2, 2, 5706, 5708, 5, 690, 346, 2, 5707, 5705, 3, 2, 2, 2, 5708, 5711, 3, 2, 2, 2, 5709, 5707, 3, 2, 2, 2, 5709, 5710, 3, 2, 2, 2, 5710, 689, 3, 2, 2, 2, 5711, 5709, 3, 2, 2, 2, 5712, 5713, 5, 686, 344, 2, 5713, 5714, 5, 684, 343, 2, 5714, 691, 3, 2, 2, 2, 5715, 5716, 7, 59, 2, 2, 5716, 5717, 5, 694, 348, 2, 5717, 693, 3, 2, 2, 2, 5718, 5720, 5, 696, 349, 2, 5719, 5718, 3, 2, 2, 2, 5720, 5721, 3, 2, 2, 2, 5721, 5719, 3, 2, 2, 2, 5721, 5722, 3, 2, 2, 2, 5722, 695, 3, 2, 2, 2, 5723, 5727, 5, 1348, 675, 2, 5724, 5725, 7, 240, 2, 2, 5725, 5727, 5, 74, 38, 2, 5726, 5723, 3, 2, 2, 2, 5726, 5724, 3, 2, 2, 2, 5727, 697, 3, 2, 2, 2, 5728, 5729, 7, 48, 2, 2, 5729, 5730, 7, 43, 2, 2, 5730, 5731, 7, 4, 2, 2, 5731, 5732, 5, 1110, 556, 2, 5732, 5733, 7, 38, 2, 2, 5733, 5734, 5, 1110, 556, 2, 5734, 5735, 7, 5, 2, 2, 5735, 5736, 7, 107, 2, 2, 5736, 5737, 7, 213, 2, 2, 5737, 5738, 5, 628, 315, 2, 5738, 5739, 5, 700, 351, 2, 5739, 5763, 3, 2, 2, 2, 5740, 5741, 7, 48, 2, 2, 5741, 5742, 7, 43, 2, 2, 5742, 5743, 7, 4, 2, 2, 5743, 5744, 5, 1110, 556, 2, 5744, 5745, 7, 38, 2, 2, 5745, 5746, 5, 1110, 556, 2, 5746, 5747, 7, 5, 2, 2, 5747, 5748, 7, 372, 2, 2, 5748, 5749, 7, 213, 2, 2, 5749, 5750, 5, 700, 351, 2, 5750, 5763, 3, 2, 2, 2, 5751, 5752, 7, 48, 2, 2, 5752, 5753, 7, 43, 2, 2, 5753, 5754, 7, 4, 2, 2, 5754, 5755, 5, 1110, 556, 2, 5755, 5756, 7, 38, 2, 2, 5756, 5757, 5, 1110, 556, 2, 5757, 5758, 7, 5, 2, 2, 5758, 5759, 7, 107, 2, 2, 5759, 5760, 7, 393, 2, 2, 5760, 5761, 5, 700, 351, 2, 5761, 5763, 3, 2, 2, 2, 5762, 5728, 3, 2, 2, 2, 5762, 5740, 3, 2, 2, 2, 5762, 5751, 3, 2, 2, 2, 5763, 699, 3, 2, 2, 2, 5764, 5765, 7, 38, 2, 2, 5765, 5770, 7, 225, 2, 2, 5766, 5767, 7, 38, 2, 2, 5767, 5770, 7, 143, 2, 2, 5768, 5770, 3, 2, 2, 2, 5769, 5764, 3, 2, 2, 2, 5769, 5766, 3, 2, 2, 2, 5769, 5768, 3, 2, 2, 2, 5770, 701, 3, 2, 2, 2, 5771, 5772, 7, 193, 2, 2, 5772, 5773, 7, 43, 2, 2, 5773, 5774, 5, 704, 353, 2, 5774, 5775, 7, 4, 2, 2, 5775, 5776, 5, 1110, 556, 2, 5776, 5777, 7, 38, 2, 2, 5777, 5778, 5, 1110, 556, 2, 5778, 5779, 7, 5, 2, 2, 5779, 5780, 5, 110, 56, 2, 5780, 703, 3, 2, 2, 2, 5781, 5782, 7, 222, 2, 2, 5782, 5785, 7, 389, 2, 2, 5783, 5785, 3, 2, 2, 2, 5784, 5781, 3, 2, 2, 2, 5784, 5783, 3, 2, 2, 2, 5785, 705, 3, 2, 2, 2, 5786, 5787, 7, 48, 2, 2, 5787, 5788, 5, 620, 311, 2, 5788, 5789, 7, 436, 2, 2, 5789, 5790, 7, 64, 2, 2, 5790, 5791, 5, 1110, 556, 2, 5791, 5792, 7, 240, 2, 2, 5792, 5793, 5, 1330, 666, 2, 5793, 5794, 7, 4, 2, 2, 5794, 5795, 5, 708, 355, 2, 5795, 5796, 7, 5, 2, 2, 5796, 707, 3, 2, 2, 2, 5797, 5798, 7, 66, 2, 2, 5798, 5799, 7, 454, 2, 2, 5799, 5800, 7, 107, 2, 2, 5800, 5801, 7, 213, 2, 2, 5801, 5802, 5, 628, 315, 2, 5802, 5803, 7, 8, 2, 2, 5803, 5804, 7, 96, 2, 2, 5804, 5805, 7, 454, 2, 2, 5805, 5806, 7, 107, 2, 2, 5806, 5807, 7, 213, 2, 2, 5807, 5808, 5, 628, 315, 2, 5808, 5832, 3, 2, 2, 2, 5809, 5810, 7, 96, 2, 2, 5810, 5811, 7, 454, 2, 2, 5811, 5812, 7, 107, 2, 2, 5812, 5813, 7, 213, 2, 2, 5813, 5814, 5, 628, 315, 2, 5814, 5815, 7, 8, 2, 2, 5815, 5816, 7, 66, 2, 2, 5816, 5817, 7, 454, 2, 2, 5817, 5818, 7, 107, 2, 2, 5818, 5819, 7, 213, 2, 2, 5819, 5820, 5, 628, 315, 2, 5820, 5832, 3, 2, 2, 2, 5821, 5822, 7, 66, 2, 2, 5822, 5823, 7, 454, 2, 2, 5823, 5824, 7, 107, 2, 2, 5824, 5825, 7, 213, 2, 2, 5825, 5832, 5, 628, 315, 2, 5826, 5827, 7, 96, 2, 2, 5827, 5828, 7, 454, 2, 2, 5828, 5829, 7, 107, 2, 2, 5829, 5830, 7, 213, 2, 2, 5830, 5832, 5, 628, 315, 2, 5831, 5797, 3, 2, 2, 2, 5831, 5809, 3, 2, 2, 2, 5831, 5821, 3, 2, 2, 2, 5831, 5826, 3, 2, 2, 2, 5832, 709, 3, 2, 2, 2, 5833, 5834, 7, 193, 2, 2, 5834, 5835, 7, 436, 2, 2, 5835, 5836, 5, 704, 353, 2, 5836, 5837, 7, 64, 2, 2, 5837, 5838, 5, 1110, 556, 2, 5838, 5839, 7, 240, 2, 2, 5839, 5840, 5, 1330, 666, 2, 5840, 5841, 5, 110, 56, 2, 5841, 711, 3, 2, 2, 2, 5842, 5843, 7, 299, 2, 2, 5843, 5844, 5, 714, 358, 2, 5844, 5845, 5, 594, 298, 2, 5845, 5846, 5, 1326, 664, 2, 5846, 5869, 3, 2, 2, 2, 5847, 5848, 7, 299, 2, 2, 5848, 5849, 5, 716, 359, 2, 5849, 5850, 5, 594, 298, 2, 5850, 5851, 5, 1330, 666, 2, 5851, 5869, 3, 2, 2, 2, 5852, 5853, 7, 299, 2, 2, 5853, 5854, 7, 4, 2, 2, 5854, 5855, 5, 718, 360, 2, 5855, 5856, 7, 5, 2, 2, 5856, 5857, 5, 714, 358, 2, 5857, 5858, 5, 594, 298, 2, 5858, 5859, 5, 1326, 664, 2, 5859, 5869, 3, 2, 2, 2, 5860, 5861, 7, 299, 2, 2, 5861, 5862, 7, 4, 2, 2, 5862, 5863, 5, 718, 360, 2, 5863, 5864, 7, 5, 2, 2, 5864, 5865, 5, 716, 359, 2, 5865, 5866, 5, 594, 298, 2, 5866, 5867, 5, 1330, 666, 2, 5867, 5869, 3, 2, 2, 2, 5868, 5842, 3, 2, 2, 2, 5868, 5847, 3, 2, 2, 2, 5868, 5852, 3, 2, 2, 2, 5868, 5860, 3, 2, 2, 2, 5869, 713, 3, 2, 2, 2, 5870, 5871, 9, 20, 2, 2, 5871, 715, 3, 2, 2, 2, 5872, 5873, 9, 30, 2, 2, 5873, 717, 3, 2, 2, 2, 5874, 5879, 5, 720, 361, 2, 5875, 5876, 7, 8, 2, 2, 5876, 5878, 5, 720, 361, 2, 5877, 5875, 3, 2, 2, 2, 5878, 5881, 3, 2, 2, 2, 5879, 5877, 3, 2, 2, 2, 5879, 5880, 3, 2, 2, 2, 5880, 719, 3, 2, 2, 2, 5881, 5879, 3, 2, 2, 2, 5882, 5883, 7, 130, 2, 2, 5883, 721, 3, 2, 2, 2, 5884, 5885, 7, 140, 2, 2, 5885, 5886, 7, 344, 2, 2, 5886, 5887, 5, 1330, 666, 2, 5887, 5888, 7, 326, 2, 2, 5888, 5889, 5, 118, 60, 2, 5889, 5897, 3, 2, 2, 2, 5890, 5891, 7, 140, 2, 2, 5891, 5892, 7, 344, 2, 2, 5892, 5893, 5, 1330, 666, 2, 5893, 5894, 7, 306, 2, 2, 5894, 5895, 5, 118, 60, 2, 5895, 5897, 3, 2, 2, 2, 5896, 5884, 3, 2, 2, 2, 5896, 5890, 3, 2, 2, 2, 5897, 723, 3, 2, 2, 2, 5898, 5899, 7, 140, 2, 2, 5899, 5900, 7, 138, 2, 2, 5900, 5901, 5, 652, 327, 2, 5901, 5902, 7, 302, 2, 2, 5902, 5903, 7, 96, 2, 2, 5903, 5904, 5, 1330, 666, 2, 5904, 6367, 3, 2, 2, 2, 5905, 5906, 7, 140, 2, 2, 5906, 5907, 7, 110, 2, 2, 5907, 5908, 5, 526, 264, 2, 5908, 5909, 7, 302, 2, 2, 5909, 5910, 7, 96, 2, 2, 5910, 5911, 5, 1330, 666, 2, 5911, 6367, 3, 2, 2, 2, 5912, 5913, 7, 140, 2, 2, 5913, 5914, 7, 170, 2, 2, 5914, 5915, 5, 526, 264, 2, 5915, 5916, 7, 302, 2, 2, 5916, 5917, 7, 96, 2, 2, 5917, 5918, 5, 1330, 666, 2, 5918, 6367, 3, 2, 2, 2, 5919, 5920, 7, 140, 2, 2, 5920, 5921, 7, 177, 2, 2, 5921, 5922, 5, 1330, 666, 2, 5922, 5923, 7, 302, 2, 2, 5923, 5924, 7, 96, 2, 2, 5924, 5925, 5, 1330, 666, 2, 5925, 6367, 3, 2, 2, 2, 5926, 5927, 7, 140, 2, 2, 5927, 5928, 7, 191, 2, 2, 5928, 5929, 5, 526, 264, 2, 5929, 5930, 7, 302, 2, 2, 5930, 5931, 7, 96, 2, 2, 5931, 5932, 5, 1330, 666, 2, 5932, 6367, 3, 2, 2, 2, 5933, 5934, 7, 140, 2, 2, 5934, 5935, 7, 191, 2, 2, 5935, 5936, 5, 526, 264, 2, 5936, 5937, 7, 302, 2, 2, 5937, 5938, 7, 47, 2, 2, 5938, 5939, 5, 1330, 666, 2, 5939, 5940, 7, 96, 2, 2, 5940, 5941, 5, 1330, 666, 2, 5941, 6367, 3, 2, 2, 2, 5942, 5943, 7, 140, 2, 2, 5943, 5944, 7, 65, 2, 2, 5944, 5945, 7, 176, 2, 2, 5945, 5946, 7, 374, 2, 2, 5946, 5947, 5, 1330, 666, 2, 5947, 5948, 7, 302, 2, 2, 5948, 5949, 7, 96, 2, 2, 5949, 5950, 5, 1330, 666, 2, 5950, 6367, 3, 2, 2, 2, 5951, 5952, 7, 140, 2, 2, 5952, 5953, 7, 213, 2, 2, 5953, 5954, 5, 628, 315, 2, 5954, 5955, 7, 302, 2, 2, 5955, 5956, 7, 96, 2, 2, 5956, 5957, 5, 1330, 666, 2, 5957, 6367, 3, 2, 2, 2, 5958, 5959, 7, 140, 2, 2, 5959, 5960, 7, 68, 2, 2, 5960, 5961, 5, 1356, 679, 2, 5961, 5962, 7, 302, 2, 2, 5962, 5963, 7, 96, 2, 2, 5963, 5964, 5, 1356, 679, 2, 5964, 6367, 3, 2, 2, 2, 5965, 5966, 7, 140, 2, 2, 5966, 5967, 5, 310, 156, 2, 5967, 5968, 7, 240, 2, 2, 5968, 5969, 5, 1330, 666, 2, 5969, 5970, 7, 302, 2, 2, 5970, 5971, 7, 96, 2, 2, 5971, 5972, 5, 1330, 666, 2, 5972, 6367, 3, 2, 2, 2, 5973, 5974, 7, 140, 2, 2, 5974, 5975, 7, 271, 2, 2, 5975, 5976, 7, 158, 2, 2, 5976, 5977, 5, 526, 264, 2, 5977, 5978, 7, 102, 2, 2, 5978, 5979, 5, 1330, 666, 2, 5979, 5980, 7, 302, 2, 2, 5980, 5981, 7, 96, 2, 2, 5981, 5982, 5, 1330, 666, 2, 5982, 6367, 3, 2, 2, 2, 5983, 5984, 7, 140, 2, 2, 5984, 5985, 7, 271, 2, 2, 5985, 5986, 7, 208, 2, 2, 5986, 5987, 5, 526, 264, 2, 5987, 5988, 7, 102, 2, 2, 5988, 5989, 5, 1330, 666, 2, 5989, 5990, 7, 302, 2, 2, 5990, 5991, 7, 96, 2, 2, 5991, 5992, 5, 1330, 666, 2, 5992, 6367, 3, 2, 2, 2, 5993, 5994, 7, 140, 2, 2, 5994, 5995, 7, 438, 2, 2, 5995, 5996, 5, 1330, 666, 2, 5996, 5997, 7, 82, 2, 2, 5997, 5998, 5, 1326, 664, 2, 5998, 5999, 7, 302, 2, 2, 5999, 6000, 7, 96, 2, 2, 6000, 6001, 5, 1330, 666, 2, 6001, 6367, 3, 2, 2, 2, 6002, 6003, 7, 140, 2, 2, 6003, 6004, 7, 438, 2, 2, 6004, 6005, 7, 222, 2, 2, 6005, 6006, 7, 389, 2, 2, 6006, 6007, 5, 1330, 666, 2, 6007, 6008, 7, 82, 2, 2, 6008, 6009, 5, 1326, 664, 2, 6009, 6010, 7, 302, 2, 2, 6010, 6011, 7, 96, 2, 2, 6011, 6012, 5, 1330, 666, 2, 6012, 6367, 3, 2, 2, 2, 6013, 6014, 7, 140, 2, 2, 6014, 6015, 7, 289, 2, 2, 6015, 6016, 5, 628, 315, 2, 6016, 6017, 7, 302, 2, 2, 6017, 6018, 7, 96, 2, 2, 6018, 6019, 5, 1330, 666, 2, 6019, 6367, 3, 2, 2, 2, 6020, 6021, 7, 140, 2, 2, 6021, 6022, 7, 445, 2, 2, 6022, 6023, 5, 1330, 666, 2, 6023, 6024, 7, 302, 2, 2, 6024, 6025, 7, 96, 2, 2, 6025, 6026, 5, 1330, 666, 2, 6026, 6367, 3, 2, 2, 2, 6027, 6028, 7, 140, 2, 2, 6028, 6029, 7, 435, 2, 2, 6029, 6030, 5, 628, 315, 2, 6030, 6031, 7, 302, 2, 2, 6031, 6032, 7, 96, 2, 2, 6032, 6033, 5, 1330, 666, 2, 6033, 6367, 3, 2, 2, 2, 6034, 6035, 7, 140, 2, 2, 6035, 6036, 7, 316, 2, 2, 6036, 6037, 5, 1330, 666, 2, 6037, 6038, 7, 302, 2, 2, 6038, 6039, 7, 96, 2, 2, 6039, 6040, 5, 1330, 666, 2, 6040, 6367, 3, 2, 2, 2, 6041, 6042, 7, 140, 2, 2, 6042, 6043, 7, 324, 2, 2, 6043, 6044, 5, 1330, 666, 2, 6044, 6045, 7, 302, 2, 2, 6045, 6046, 7, 96, 2, 2, 6046, 6047, 5, 1330, 666, 2, 6047, 6367, 3, 2, 2, 2, 6048, 6049, 7, 140, 2, 2, 6049, 6050, 7, 444, 2, 2, 6050, 6051, 5, 1330, 666, 2, 6051, 6052, 7, 302, 2, 2, 6052, 6053, 7, 96, 2, 2, 6053, 6054, 5, 1330, 666, 2, 6054, 6367, 3, 2, 2, 2, 6055, 6056, 7, 140, 2, 2, 6056, 6057, 7, 94, 2, 2, 6057, 6058, 5, 1066, 534, 2, 6058, 6059, 7, 302, 2, 2, 6059, 6060, 7, 96, 2, 2, 6060, 6061, 5, 1330, 666, 2, 6061, 6367, 3, 2, 2, 2, 6062, 6063, 7, 140, 2, 2, 6063, 6064, 7, 94, 2, 2, 6064, 6065, 7, 222, 2, 2, 6065, 6066, 7, 389, 2, 2, 6066, 6067, 5, 1066, 534, 2, 6067, 6068, 7, 302, 2, 2, 6068, 6069, 7, 96, 2, 2, 6069, 6070, 5, 1330, 666, 2, 6070, 6367, 3, 2, 2, 2, 6071, 6072, 7, 140, 2, 2, 6072, 6073, 7, 321, 2, 2, 6073, 6074, 5, 1326, 664, 2, 6074, 6075, 7, 302, 2, 2, 6075, 6076, 7, 96, 2, 2, 6076, 6077, 5, 1330, 666, 2, 6077, 6367, 3, 2, 2, 2, 6078, 6079, 7, 140, 2, 2, 6079, 6080, 7, 321, 2, 2, 6080, 6081, 7, 222, 2, 2, 6081, 6082, 7, 389, 2, 2, 6082, 6083, 5, 1326, 664, 2, 6083, 6084, 7, 302, 2, 2, 6084, 6085, 7, 96, 2, 2, 6085, 6086, 5, 1330, 666, 2, 6086, 6367, 3, 2, 2, 2, 6087, 6088, 7, 140, 2, 2, 6088, 6089, 7, 369, 2, 2, 6089, 6090, 5, 1326, 664, 2, 6090, 6091, 7, 302, 2, 2, 6091, 6092, 7, 96, 2, 2, 6092, 6093, 5, 1330, 666, 2, 6093, 6367, 3, 2, 2, 2, 6094, 6095, 7, 140, 2, 2, 6095, 6096, 7, 369, 2, 2, 6096, 6097, 7, 222, 2, 2, 6097, 6098, 7, 389, 2, 2, 6098, 6099, 5, 1326, 664, 2, 6099, 6100, 7, 302, 2, 2, 6100, 6101, 7, 96, 2, 2, 6101, 6102, 5, 1330, 666, 2, 6102, 6367, 3, 2, 2, 2, 6103, 6104, 7, 140, 2, 2, 6104, 6105, 7, 252, 2, 2, 6105, 6106, 7, 369, 2, 2, 6106, 6107, 5, 1326, 664, 2, 6107, 6108, 7, 302, 2, 2, 6108, 6109, 7, 96, 2, 2, 6109, 6110, 5, 1330, 666, 2, 6110, 6367, 3, 2, 2, 2, 6111, 6112, 7, 140, 2, 2, 6112, 6113, 7, 252, 2, 2, 6113, 6114, 7, 369, 2, 2, 6114, 6115, 7, 222, 2, 2, 6115, 6116, 7, 389, 2, 2, 6116, 6117, 5, 1326, 664, 2, 6117, 6118, 7, 302, 2, 2, 6118, 6119, 7, 96, 2, 2, 6119, 6120, 5, 1330, 666, 2, 6120, 6367, 3, 2, 2, 2, 6121, 6122, 7, 140, 2, 2, 6122, 6123, 7, 228, 2, 2, 6123, 6124, 5, 1326, 664, 2, 6124, 6125, 7, 302, 2, 2, 6125, 6126, 7, 96, 2, 2, 6126, 6127, 5, 1330, 666, 2, 6127, 6367, 3, 2, 2, 2, 6128, 6129, 7, 140, 2, 2, 6129, 6130, 7, 228, 2, 2, 6130, 6131, 7, 222, 2, 2, 6131, 6132, 7, 389, 2, 2, 6132, 6133, 5, 1326, 664, 2, 6133, 6134, 7, 302, 2, 2, 6134, 6135, 7, 96, 2, 2, 6135, 6136, 5, 1330, 666, 2, 6136, 6367, 3, 2, 2, 2, 6137, 6138, 7, 140, 2, 2, 6138, 6139, 7, 65, 2, 2, 6139, 6140, 7, 94, 2, 2, 6140, 6141, 5, 1066, 534, 2, 6141, 6142, 7, 302, 2, 2, 6142, 6143, 7, 96, 2, 2, 6143, 6144, 5, 1330, 666, 2, 6144, 6367, 3, 2, 2, 2, 6145, 6146, 7, 140, 2, 2, 6146, 6147, 7, 65, 2, 2, 6147, 6148, 7, 94, 2, 2, 6148, 6149, 7, 222, 2, 2, 6149, 6150, 7, 389, 2, 2, 6150, 6151, 5, 1066, 534, 2, 6151, 6152, 7, 302, 2, 2, 6152, 6153, 7, 96, 2, 2, 6153, 6154, 5, 1330, 666, 2, 6154, 6367, 3, 2, 2, 2, 6155, 6156, 7, 140, 2, 2, 6156, 6157, 7, 94, 2, 2, 6157, 6158, 5, 1066, 534, 2, 6158, 6159, 7, 302, 2, 2, 6159, 6160, 5, 726, 364, 2, 6160, 6161, 5, 1330, 666, 2, 6161, 6162, 7, 96, 2, 2, 6162, 6163, 5, 1330, 666, 2, 6163, 6367, 3, 2, 2, 2, 6164, 6165, 7, 140, 2, 2, 6165, 6166, 7, 94, 2, 2, 6166, 6167, 7, 222, 2, 2, 6167, 6168, 7, 389, 2, 2, 6168, 6169, 5, 1066, 534, 2, 6169, 6170, 7, 302, 2, 2, 6170, 6171, 5, 726, 364, 2, 6171, 6172, 5, 1330, 666, 2, 6172, 6173, 7, 96, 2, 2, 6173, 6174, 5, 1330, 666, 2, 6174, 6367, 3, 2, 2, 2, 6175, 6176, 7, 140, 2, 2, 6176, 6177, 7, 369, 2, 2, 6177, 6178, 5, 1326, 664, 2, 6178, 6179, 7, 302, 2, 2, 6179, 6180, 5, 726, 364, 2, 6180, 6181, 5, 1330, 666, 2, 6181, 6182, 7, 96, 2, 2, 6182, 6183, 5, 1330, 666, 2, 6183, 6367, 3, 2, 2, 2, 6184, 6185, 7, 140, 2, 2, 6185, 6186, 7, 369, 2, 2, 6186, 6187, 7, 222, 2, 2, 6187, 6188, 7, 389, 2, 2, 6188, 6189, 5, 1326, 664, 2, 6189, 6190, 7, 302, 2, 2, 6190, 6191, 5, 726, 364, 2, 6191, 6192, 5, 1330, 666, 2, 6192, 6193, 7, 96, 2, 2, 6193, 6194, 5, 1330, 666, 2, 6194, 6367, 3, 2, 2, 2, 6195, 6196, 7, 140, 2, 2, 6196, 6197, 7, 252, 2, 2, 6197, 6198, 7, 369, 2, 2, 6198, 6199, 5, 1326, 664, 2, 6199, 6200, 7, 302, 2, 2, 6200, 6201, 5, 726, 364, 2, 6201, 6202, 5, 1330, 666, 2, 6202, 6203, 7, 96, 2, 2, 6203, 6204, 5, 1330, 666, 2, 6204, 6367, 3, 2, 2, 2, 6205, 6206, 7, 140, 2, 2, 6206, 6207, 7, 252, 2, 2, 6207, 6208, 7, 369, 2, 2, 6208, 6209, 7, 222, 2, 2, 6209, 6210, 7, 389, 2, 2, 6210, 6211, 5, 1326, 664, 2, 6211, 6212, 7, 302, 2, 2, 6212, 6213, 5, 726, 364, 2, 6213, 6214, 5, 1330, 666, 2, 6214, 6215, 7, 96, 2, 2, 6215, 6216, 5, 1330, 666, 2, 6216, 6367, 3, 2, 2, 2, 6217, 6218, 7, 140, 2, 2, 6218, 6219, 7, 94, 2, 2, 6219, 6220, 5, 1066, 534, 2, 6220, 6221, 7, 302, 2, 2, 6221, 6222, 7, 47, 2, 2, 6222, 6223, 5, 1330, 666, 2, 6223, 6224, 7, 96, 2, 2, 6224, 6225, 5, 1330, 666, 2, 6225, 6367, 3, 2, 2, 2, 6226, 6227, 7, 140, 2, 2, 6227, 6228, 7, 94, 2, 2, 6228, 6229, 7, 222, 2, 2, 6229, 6230, 7, 389, 2, 2, 6230, 6231, 5, 1066, 534, 2, 6231, 6232, 7, 302, 2, 2, 6232, 6233, 7, 47, 2, 2, 6233, 6234, 5, 1330, 666, 2, 6234, 6235, 7, 96, 2, 2, 6235, 6236, 5, 1330, 666, 2, 6236, 6367, 3, 2, 2, 2, 6237, 6238, 7, 140, 2, 2, 6238, 6239, 7, 65, 2, 2, 6239, 6240, 7, 94, 2, 2, 6240, 6241, 5, 1066, 534, 2, 6241, 6242, 7, 302, 2, 2, 6242, 6243, 5, 726, 364, 2, 6243, 6244, 5, 1330, 666, 2, 6244, 6245, 7, 96, 2, 2, 6245, 6246, 5, 1330, 666, 2, 6246, 6367, 3, 2, 2, 2, 6247, 6248, 7, 140, 2, 2, 6248, 6249, 7, 65, 2, 2, 6249, 6250, 7, 94, 2, 2, 6250, 6251, 7, 222, 2, 2, 6251, 6252, 7, 389, 2, 2, 6252, 6253, 5, 1066, 534, 2, 6253, 6254, 7, 302, 2, 2, 6254, 6255, 5, 726, 364, 2, 6255, 6256, 5, 1330, 666, 2, 6256, 6257, 7, 96, 2, 2, 6257, 6258, 5, 1330, 666, 2, 6258, 6367, 3, 2, 2, 2, 6259, 6260, 7, 140, 2, 2, 6260, 6261, 7, 314, 2, 2, 6261, 6262, 5, 1330, 666, 2, 6262, 6263, 7, 82, 2, 2, 6263, 6264, 5, 1326, 664, 2, 6264, 6265, 7, 302, 2, 2, 6265, 6266, 7, 96, 2, 2, 6266, 6267, 5, 1330, 666, 2, 6267, 6367, 3, 2, 2, 2, 6268, 6269, 7, 140, 2, 2, 6269, 6270, 7, 350, 2, 2, 6270, 6271, 5, 1330, 666, 2, 6271, 6272, 7, 82, 2, 2, 6272, 6273, 5, 1326, 664, 2, 6273, 6274, 7, 302, 2, 2, 6274, 6275, 7, 96, 2, 2, 6275, 6276, 5, 1330, 666, 2, 6276, 6367, 3, 2, 2, 2, 6277, 6278, 7, 140, 2, 2, 6278, 6279, 7, 200, 2, 2, 6279, 6280, 7, 350, 2, 2, 6280, 6281, 5, 1330, 666, 2, 6281, 6282, 7, 302, 2, 2, 6282, 6283, 7, 96, 2, 2, 6283, 6284, 5, 1330, 666, 2, 6284, 6367, 3, 2, 2, 2, 6285, 6286, 7, 140, 2, 2, 6286, 6287, 7, 311, 2, 2, 6287, 6288, 5, 1356, 679, 2, 6288, 6289, 7, 302, 2, 2, 6289, 6290, 7, 96, 2, 2, 6290, 6291, 5, 1356, 679, 2, 6291, 6367, 3, 2, 2, 2, 6292, 6293, 7, 140, 2, 2, 6293, 6294, 7, 101, 2, 2, 6294, 6295, 5, 1356, 679, 2, 6295, 6296, 7, 302, 2, 2, 6296, 6297, 7, 96, 2, 2, 6297, 6298, 5, 1356, 679, 2, 6298, 6367, 3, 2, 2, 2, 6299, 6300, 7, 140, 2, 2, 6300, 6301, 7, 344, 2, 2, 6301, 6302, 5, 1330, 666, 2, 6302, 6303, 7, 302, 2, 2, 6303, 6304, 7, 96, 2, 2, 6304, 6305, 5, 1330, 666, 2, 6305, 6367, 3, 2, 2, 2, 6306, 6307, 7, 140, 2, 2, 6307, 6308, 7, 335, 2, 2, 6308, 6309, 5, 526, 264, 2, 6309, 6310, 7, 302, 2, 2, 6310, 6311, 7, 96, 2, 2, 6311, 6312, 5, 1330, 666, 2, 6312, 6367, 3, 2, 2, 2, 6313, 6314, 7, 140, 2, 2, 6314, 6315, 7, 348, 2, 2, 6315, 6316, 7, 318, 2, 2, 6316, 6317, 7, 276, 2, 2, 6317, 6318, 5, 526, 264, 2, 6318, 6319, 7, 302, 2, 2, 6319, 6320, 7, 96, 2, 2, 6320, 6321, 5, 1330, 666, 2, 6321, 6367, 3, 2, 2, 2, 6322, 6323, 7, 140, 2, 2, 6323, 6324, 7, 348, 2, 2, 6324, 6325, 7, 318, 2, 2, 6325, 6326, 7, 187, 2, 2, 6326, 6327, 5, 526, 264, 2, 6327, 6328, 7, 302, 2, 2, 6328, 6329, 7, 96, 2, 2, 6329, 6330, 5, 1330, 666, 2, 6330, 6367, 3, 2, 2, 2, 6331, 6332, 7, 140, 2, 2, 6332, 6333, 7, 348, 2, 2, 6333, 6334, 7, 318, 2, 2, 6334, 6335, 7, 346, 2, 2, 6335, 6336, 5, 526, 264, 2, 6336, 6337, 7, 302, 2, 2, 6337, 6338, 7, 96, 2, 2, 6338, 6339, 5, 1330, 666, 2, 6339, 6367, 3, 2, 2, 2, 6340, 6341, 7, 140, 2, 2, 6341, 6342, 7, 348, 2, 2, 6342, 6343, 7, 318, 2, 2, 6343, 6344, 7, 165, 2, 2, 6344, 6345, 5, 526, 264, 2, 6345, 6346, 7, 302, 2, 2, 6346, 6347, 7, 96, 2, 2, 6347, 6348, 5, 1330, 666, 2, 6348, 6367, 3, 2, 2, 2, 6349, 6350, 7, 140, 2, 2, 6350, 6351, 7, 353, 2, 2, 6351, 6352, 5, 526, 264, 2, 6352, 6353, 7, 302, 2, 2, 6353, 6354, 7, 96, 2, 2, 6354, 6355, 5, 1330, 666, 2, 6355, 6367, 3, 2, 2, 2, 6356, 6357, 7, 140, 2, 2, 6357, 6358, 7, 353, 2, 2, 6358, 6359, 5, 526, 264, 2, 6359, 6360, 7, 302, 2, 2, 6360, 6361, 7, 145, 2, 2, 6361, 6362, 5, 1330, 666, 2, 6362, 6363, 7, 96, 2, 2, 6363, 6364, 5, 1330, 666, 2, 6364, 6365, 5, 110, 56, 2, 6365, 6367, 3, 2, 2, 2, 6366, 5898, 3, 2, 2, 2, 6366, 5905, 3, 2, 2, 2, 6366, 5912, 3, 2, 2, 2, 6366, 5919, 3, 2, 2, 2, 6366, 5926, 3, 2, 2, 2, 6366, 5933, 3, 2, 2, 2, 6366, 5942, 3, 2, 2, 2, 6366, 5951, 3, 2, 2, 2, 6366, 5958, 3, 2, 2, 2, 6366, 5965, 3, 2, 2, 2, 6366, 5973, 3, 2, 2, 2, 6366, 5983, 3, 2, 2, 2, 6366, 5993, 3, 2, 2, 2, 6366, 6002, 3, 2, 2, 2, 6366, 6013, 3, 2, 2, 2, 6366, 6020, 3, 2, 2, 2, 6366, 6027, 3, 2, 2, 2, 6366, 6034, 3, 2, 2, 2, 6366, 6041, 3, 2, 2, 2, 6366, 6048, 3, 2, 2, 2, 6366, 6055, 3, 2, 2, 2, 6366, 6062, 3, 2, 2, 2, 6366, 6071, 3, 2, 2, 2, 6366, 6078, 3, 2, 2, 2, 6366, 6087, 3, 2, 2, 2, 6366, 6094, 3, 2, 2, 2, 6366, 6103, 3, 2, 2, 2, 6366, 6111, 3, 2, 2, 2, 6366, 6121, 3, 2, 2, 2, 6366, 6128, 3, 2, 2, 2, 6366, 6137, 3, 2, 2, 2, 6366, 6145, 3, 2, 2, 2, 6366, 6155, 3, 2, 2, 2, 6366, 6164, 3, 2, 2, 2, 6366, 6175, 3, 2, 2, 2, 6366, 6184, 3, 2, 2, 2, 6366, 6195, 3, 2, 2, 2, 6366, 6205, 3, 2, 2, 2, 6366, 6217, 3, 2, 2, 2, 6366, 6226, 3, 2, 2, 2, 6366, 6237, 3, 2, 2, 2, 6366, 6247, 3, 2, 2, 2, 6366, 6259, 3, 2, 2, 2, 6366, 6268, 3, 2, 2, 2, 6366, 6277, 3, 2, 2, 2, 6366, 6285, 3, 2, 2, 2, 6366, 6292, 3, 2, 2, 2, 6366, 6299, 3, 2, 2, 2, 6366, 6306, 3, 2, 2, 2, 6366, 6313, 3, 2, 2, 2, 6366, 6322, 3, 2, 2, 2, 6366, 6331, 3, 2, 2, 2, 6366, 6340, 3, 2, 2, 2, 6366, 6349, 3, 2, 2, 2, 6366, 6356, 3, 2, 2, 2, 6367, 725, 3, 2, 2, 2, 6368, 6371, 7, 46, 2, 2, 6369, 6371, 3, 2, 2, 2, 6370, 6368, 3, 2, 2, 2, 6370, 6369, 3, 2, 2, 2, 6371, 727, 3, 2, 2, 2, 6372, 6373, 7, 326, 2, 2, 6373, 6376, 7, 176, 2, 2, 6374, 6376, 3, 2, 2, 2, 6375, 6372, 3, 2, 2, 2, 6375, 6374, 3, 2, 2, 2, 6376, 729, 3, 2, 2, 2, 6377, 6378, 7, 140, 2, 2, 6378, 6379, 7, 213, 2, 2, 6379, 6380, 5, 628, 315, 2, 6380, 6381, 5, 732, 367, 2, 6381, 6382, 7, 455, 2, 2, 6382, 6383, 7, 82, 2, 2, 6383, 6384, 7, 206, 2, 2, 6384, 6385, 5, 1330, 666, 2, 6385, 6435, 3, 2, 2, 2, 6386, 6387, 7, 140, 2, 2, 6387, 6388, 7, 289, 2, 2, 6388, 6389, 5, 628, 315, 2, 6389, 6390, 5, 732, 367, 2, 6390, 6391, 7, 455, 2, 2, 6391, 6392, 7, 82, 2, 2, 6392, 6393, 7, 206, 2, 2, 6393, 6394, 5, 1330, 666, 2, 6394, 6435, 3, 2, 2, 2, 6395, 6396, 7, 140, 2, 2, 6396, 6397, 7, 435, 2, 2, 6397, 6398, 5, 628, 315, 2, 6398, 6399, 5, 732, 367, 2, 6399, 6400, 7, 455, 2, 2, 6400, 6401, 7, 82, 2, 2, 6401, 6402, 7, 206, 2, 2, 6402, 6403, 5, 1330, 666, 2, 6403, 6435, 3, 2, 2, 2, 6404, 6405, 7, 140, 2, 2, 6405, 6406, 7, 350, 2, 2, 6406, 6407, 5, 1330, 666, 2, 6407, 6408, 7, 82, 2, 2, 6408, 6409, 5, 1326, 664, 2, 6409, 6410, 5, 732, 367, 2, 6410, 6411, 7, 455, 2, 2, 6411, 6412, 7, 82, 2, 2, 6412, 6413, 7, 206, 2, 2, 6413, 6414, 5, 1330, 666, 2, 6414, 6435, 3, 2, 2, 2, 6415, 6416, 7, 140, 2, 2, 6416, 6417, 7, 252, 2, 2, 6417, 6418, 7, 369, 2, 2, 6418, 6419, 5, 1326, 664, 2, 6419, 6420, 5, 732, 367, 2, 6420, 6421, 7, 455, 2, 2, 6421, 6422, 7, 82, 2, 2, 6422, 6423, 7, 206, 2, 2, 6423, 6424, 5, 1330, 666, 2, 6424, 6435, 3, 2, 2, 2, 6425, 6426, 7, 140, 2, 2, 6426, 6427, 7, 228, 2, 2, 6427, 6428, 5, 1326, 664, 2, 6428, 6429, 5, 732, 367, 2, 6429, 6430, 7, 455, 2, 2, 6430, 6431, 7, 82, 2, 2, 6431, 6432, 7, 206, 2, 2, 6432, 6433, 5, 1330, 666, 2, 6433, 6435, 3, 2, 2, 2, 6434, 6377, 3, 2, 2, 2, 6434, 6386, 3, 2, 2, 2, 6434, 6395, 3, 2, 2, 2, 6434, 6404, 3, 2, 2, 2, 6434, 6415, 3, 2, 2, 2, 6434, 6425, 3, 2, 2, 2, 6435, 731, 3, 2, 2, 2, 6436, 6439, 7, 262, 2, 2, 6437, 6439, 3, 2, 2, 2, 6438, 6436, 3, 2, 2, 2, 6438, 6437, 3, 2, 2, 2, 6439, 733, 3, 2, 2, 2, 6440, 6441, 7, 140, 2, 2, 6441, 6442, 7, 138, 2, 2, 6442, 6443, 5, 652, 327, 2, 6443, 6444, 7, 326, 2, 2, 6444, 6445, 7, 316, 2, 2, 6445, 6446, 5, 1330, 666, 2, 6446, 6658, 3, 2, 2, 2, 6447, 6448, 7, 140, 2, 2, 6448, 6449, 7, 110, 2, 2, 6449, 6450, 5, 526, 264, 2, 6450, 6451, 7, 326, 2, 2, 6451, 6452, 7, 316, 2, 2, 6452, 6453, 5, 1330, 666, 2, 6453, 6658, 3, 2, 2, 2, 6454, 6455, 7, 140, 2, 2, 6455, 6456, 7, 170, 2, 2, 6456, 6457, 5, 526, 264, 2, 6457, 6458, 7, 326, 2, 2, 6458, 6459, 7, 316, 2, 2, 6459, 6460, 5, 1330, 666, 2, 6460, 6658, 3, 2, 2, 2, 6461, 6462, 7, 140, 2, 2, 6462, 6463, 7, 191, 2, 2, 6463, 6464, 5, 526, 264, 2, 6464, 6465, 7, 326, 2, 2, 6465, 6466, 7, 316, 2, 2, 6466, 6467, 5, 1330, 666, 2, 6467, 6658, 3, 2, 2, 2, 6468, 6469, 7, 140, 2, 2, 6469, 6470, 7, 206, 2, 2, 6470, 6471, 5, 1330, 666, 2, 6471, 6472, 7, 326, 2, 2, 6472, 6473, 7, 316, 2, 2, 6473, 6474, 5, 1330, 666, 2, 6474, 6658, 3, 2, 2, 2, 6475, 6476, 7, 140, 2, 2, 6476, 6477, 7, 213, 2, 2, 6477, 6478, 5, 628, 315, 2, 6478, 6479, 7, 326, 2, 2, 6479, 6480, 7, 316, 2, 2, 6480, 6481, 5, 1330, 666, 2, 6481, 6658, 3, 2, 2, 2, 6482, 6483, 7, 140, 2, 2, 6483, 6484, 7, 271, 2, 2, 6484, 6485, 5, 690, 346, 2, 6485, 6486, 7, 326, 2, 2, 6486, 6487, 7, 316, 2, 2, 6487, 6488, 5, 1330, 666, 2, 6488, 6658, 3, 2, 2, 2, 6489, 6490, 7, 140, 2, 2, 6490, 6491, 7, 271, 2, 2, 6491, 6492, 7, 158, 2, 2, 6492, 6493, 5, 526, 264, 2, 6493, 6494, 7, 102, 2, 2, 6494, 6495, 5, 1330, 666, 2, 6495, 6496, 7, 326, 2, 2, 6496, 6497, 7, 316, 2, 2, 6497, 6498, 5, 1330, 666, 2, 6498, 6658, 3, 2, 2, 2, 6499, 6500, 7, 140, 2, 2, 6500, 6501, 7, 271, 2, 2, 6501, 6502, 7, 208, 2, 2, 6502, 6503, 5, 526, 264, 2, 6503, 6504, 7, 102, 2, 2, 6504, 6505, 5, 1330, 666, 2, 6505, 6506, 7, 326, 2, 2, 6506, 6507, 7, 316, 2, 2, 6507, 6508, 5, 1330, 666, 2, 6508, 6658, 3, 2, 2, 2, 6509, 6510, 7, 140, 2, 2, 6510, 6511, 7, 289, 2, 2, 6511, 6512, 5, 628, 315, 2, 6512, 6513, 7, 326, 2, 2, 6513, 6514, 7, 316, 2, 2, 6514, 6515, 5, 1330, 666, 2, 6515, 6658, 3, 2, 2, 2, 6516, 6517, 7, 140, 2, 2, 6517, 6518, 7, 435, 2, 2, 6518, 6519, 5, 628, 315, 2, 6519, 6520, 7, 326, 2, 2, 6520, 6521, 7, 316, 2, 2, 6521, 6522, 5, 1330, 666, 2, 6522, 6658, 3, 2, 2, 2, 6523, 6524, 7, 140, 2, 2, 6524, 6525, 7, 94, 2, 2, 6525, 6526, 5, 1066, 534, 2, 6526, 6527, 7, 326, 2, 2, 6527, 6528, 7, 316, 2, 2, 6528, 6529, 5, 1330, 666, 2, 6529, 6658, 3, 2, 2, 2, 6530, 6531, 7, 140, 2, 2, 6531, 6532, 7, 94, 2, 2, 6532, 6533, 7, 222, 2, 2, 6533, 6534, 7, 389, 2, 2, 6534, 6535, 5, 1066, 534, 2, 6535, 6536, 7, 326, 2, 2, 6536, 6537, 7, 316, 2, 2, 6537, 6538, 5, 1330, 666, 2, 6538, 6658, 3, 2, 2, 2, 6539, 6540, 7, 140, 2, 2, 6540, 6541, 7, 335, 2, 2, 6541, 6542, 5, 526, 264, 2, 6542, 6543, 7, 326, 2, 2, 6543, 6544, 7, 316, 2, 2, 6544, 6545, 5, 1330, 666, 2, 6545, 6658, 3, 2, 2, 2, 6546, 6547, 7, 140, 2, 2, 6547, 6548, 7, 348, 2, 2, 6548, 6549, 7, 318, 2, 2, 6549, 6550, 7, 276, 2, 2, 6550, 6551, 5, 526, 264, 2, 6551, 6552, 7, 326, 2, 2, 6552, 6553, 7, 316, 2, 2, 6553, 6554, 5, 1330, 666, 2, 6554, 6658, 3, 2, 2, 2, 6555, 6556, 7, 140, 2, 2, 6556, 6557, 7, 348, 2, 2, 6557, 6558, 7, 318, 2, 2, 6558, 6559, 7, 187, 2, 2, 6559, 6560, 5, 526, 264, 2, 6560, 6561, 7, 326, 2, 2, 6561, 6562, 7, 316, 2, 2, 6562, 6563, 5, 1330, 666, 2, 6563, 6658, 3, 2, 2, 2, 6564, 6565, 7, 140, 2, 2, 6565, 6566, 7, 348, 2, 2, 6566, 6567, 7, 318, 2, 2, 6567, 6568, 7, 346, 2, 2, 6568, 6569, 5, 526, 264, 2, 6569, 6570, 7, 326, 2, 2, 6570, 6571, 7, 316, 2, 2, 6571, 6572, 5, 1330, 666, 2, 6572, 6658, 3, 2, 2, 2, 6573, 6574, 7, 140, 2, 2, 6574, 6575, 7, 348, 2, 2, 6575, 6576, 7, 318, 2, 2, 6576, 6577, 7, 165, 2, 2, 6577, 6578, 5, 526, 264, 2, 6578, 6579, 7, 326, 2, 2, 6579, 6580, 7, 316, 2, 2, 6580, 6581, 5, 1330, 666, 2, 6581, 6658, 3, 2, 2, 2, 6582, 6583, 7, 140, 2, 2, 6583, 6584, 7, 321, 2, 2, 6584, 6585, 5, 1326, 664, 2, 6585, 6586, 7, 326, 2, 2, 6586, 6587, 7, 316, 2, 2, 6587, 6588, 5, 1330, 666, 2, 6588, 6658, 3, 2, 2, 2, 6589, 6590, 7, 140, 2, 2, 6590, 6591, 7, 321, 2, 2, 6591, 6592, 7, 222, 2, 2, 6592, 6593, 7, 389, 2, 2, 6593, 6594, 5, 1326, 664, 2, 6594, 6595, 7, 326, 2, 2, 6595, 6596, 7, 316, 2, 2, 6596, 6597, 5, 1330, 666, 2, 6597, 6658, 3, 2, 2, 2, 6598, 6599, 7, 140, 2, 2, 6599, 6600, 7, 369, 2, 2, 6600, 6601, 5, 1326, 664, 2, 6601, 6602, 7, 326, 2, 2, 6602, 6603, 7, 316, 2, 2, 6603, 6604, 5, 1330, 666, 2, 6604, 6658, 3, 2, 2, 2, 6605, 6606, 7, 140, 2, 2, 6606, 6607, 7, 369, 2, 2, 6607, 6608, 7, 222, 2, 2, 6608, 6609, 7, 389, 2, 2, 6609, 6610, 5, 1326, 664, 2, 6610, 6611, 7, 326, 2, 2, 6611, 6612, 7, 316, 2, 2, 6612, 6613, 5, 1330, 666, 2, 6613, 6658, 3, 2, 2, 2, 6614, 6615, 7, 140, 2, 2, 6615, 6616, 7, 252, 2, 2, 6616, 6617, 7, 369, 2, 2, 6617, 6618, 5, 1326, 664, 2, 6618, 6619, 7, 326, 2, 2, 6619, 6620, 7, 316, 2, 2, 6620, 6621, 5, 1330, 666, 2, 6621, 6658, 3, 2, 2, 2, 6622, 6623, 7, 140, 2, 2, 6623, 6624, 7, 252, 2, 2, 6624, 6625, 7, 369, 2, 2, 6625, 6626, 7, 222, 2, 2, 6626, 6627, 7, 389, 2, 2, 6627, 6628, 5, 1326, 664, 2, 6628, 6629, 7, 326, 2, 2, 6629, 6630, 7, 316, 2, 2, 6630, 6631, 5, 1330, 666, 2, 6631, 6658, 3, 2, 2, 2, 6632, 6633, 7, 140, 2, 2, 6633, 6634, 7, 65, 2, 2, 6634, 6635, 7, 94, 2, 2, 6635, 6636, 5, 1066, 534, 2, 6636, 6637, 7, 326, 2, 2, 6637, 6638, 7, 316, 2, 2, 6638, 6639, 5, 1330, 666, 2, 6639, 6658, 3, 2, 2, 2, 6640, 6641, 7, 140, 2, 2, 6641, 6642, 7, 65, 2, 2, 6642, 6643, 7, 94, 2, 2, 6643, 6644, 7, 222, 2, 2, 6644, 6645, 7, 389, 2, 2, 6645, 6646, 5, 1066, 534, 2, 6646, 6647, 7, 326, 2, 2, 6647, 6648, 7, 316, 2, 2, 6648, 6649, 5, 1330, 666, 2, 6649, 6658, 3, 2, 2, 2, 6650, 6651, 7, 140, 2, 2, 6651, 6652, 7, 353, 2, 2, 6652, 6653, 5, 526, 264, 2, 6653, 6654, 7, 326, 2, 2, 6654, 6655, 7, 316, 2, 2, 6655, 6656, 5, 1330, 666, 2, 6656, 6658, 3, 2, 2, 2, 6657, 6440, 3, 2, 2, 2, 6657, 6447, 3, 2, 2, 2, 6657, 6454, 3, 2, 2, 2, 6657, 6461, 3, 2, 2, 2, 6657, 6468, 3, 2, 2, 2, 6657, 6475, 3, 2, 2, 2, 6657, 6482, 3, 2, 2, 2, 6657, 6489, 3, 2, 2, 2, 6657, 6499, 3, 2, 2, 2, 6657, 6509, 3, 2, 2, 2, 6657, 6516, 3, 2, 2, 2, 6657, 6523, 3, 2, 2, 2, 6657, 6530, 3, 2, 2, 2, 6657, 6539, 3, 2, 2, 2, 6657, 6546, 3, 2, 2, 2, 6657, 6555, 3, 2, 2, 2, 6657, 6564, 3, 2, 2, 2, 6657, 6573, 3, 2, 2, 2, 6657, 6582, 3, 2, 2, 2, 6657, 6589, 3, 2, 2, 2, 6657, 6598, 3, 2, 2, 2, 6657, 6605, 3, 2, 2, 2, 6657, 6614, 3, 2, 2, 2, 6657, 6622, 3, 2, 2, 2, 6657, 6632, 3, 2, 2, 2, 6657, 6640, 3, 2, 2, 2, 6657, 6650, 3, 2, 2, 2, 6658, 735, 3, 2, 2, 2, 6659, 6660, 7, 140, 2, 2, 6660, 6661, 7, 271, 2, 2, 6661, 6662, 5, 690, 346, 2, 6662, 6663, 7, 326, 2, 2, 6663, 6664, 7, 4, 2, 2, 6664, 6665, 5, 738, 370, 2, 6665, 6666, 7, 5, 2, 2, 6666, 737, 3, 2, 2, 2, 6667, 6672, 5, 740, 371, 2, 6668, 6669, 7, 8, 2, 2, 6669, 6671, 5, 740, 371, 2, 6670, 6668, 3, 2, 2, 2, 6671, 6674, 3, 2, 2, 2, 6672, 6670, 3, 2, 2, 2, 6672, 6673, 3, 2, 2, 2, 6673, 739, 3, 2, 2, 2, 6674, 6672, 3, 2, 2, 2, 6675, 6676, 5, 1368, 685, 2, 6676, 6677, 7, 12, 2, 2, 6677, 6678, 7, 400, 2, 2, 6678, 6684, 3, 2, 2, 2, 6679, 6680, 5, 1368, 685, 2, 6680, 6681, 7, 12, 2, 2, 6681, 6682, 5, 742, 372, 2, 6682, 6684, 3, 2, 2, 2, 6683, 6675, 3, 2, 2, 2, 6683, 6679, 3, 2, 2, 2, 6684, 741, 3, 2, 2, 2, 6685, 6691, 5, 642, 322, 2, 6686, 6691, 5, 1380, 691, 2, 6687, 6691, 5, 1266, 634, 2, 6688, 6691, 5, 294, 148, 2, 6689, 6691, 5, 1348, 675, 2, 6690, 6685, 3, 2, 2, 2, 6690, 6686, 3, 2, 2, 2, 6690, 6687, 3, 2, 2, 2, 6690, 6688, 3, 2, 2, 2, 6690, 6689, 3, 2, 2, 2, 6691, 743, 3, 2, 2, 2, 6692, 6693, 7, 140, 2, 2, 6693, 6694, 7, 353, 2, 2, 6694, 6695, 5, 526, 264, 2, 6695, 6696, 7, 326, 2, 2, 6696, 6697, 7, 4, 2, 2, 6697, 6698, 5, 738, 370, 2, 6698, 6699, 7, 5, 2, 2, 6699, 745, 3, 2, 2, 2, 6700, 6701, 7, 140, 2, 2, 6701, 6702, 7, 138, 2, 2, 6702, 6703, 5, 652, 327, 2, 6703, 6704, 7, 275, 2, 2, 6704, 6705, 7, 96, 2, 2, 6705, 6706, 5, 1358, 680, 2, 6706, 6884, 3, 2, 2, 2, 6707, 6708, 7, 140, 2, 2, 6708, 6709, 7, 110, 2, 2, 6709, 6710, 5, 526, 264, 2, 6710, 6711, 7, 275, 2, 2, 6711, 6712, 7, 96, 2, 2, 6712, 6713, 5, 1358, 680, 2, 6713, 6884, 3, 2, 2, 2, 6714, 6715, 7, 140, 2, 2, 6715, 6716, 7, 170, 2, 2, 6716, 6717, 5, 526, 264, 2, 6717, 6718, 7, 275, 2, 2, 6718, 6719, 7, 96, 2, 2, 6719, 6720, 5, 1358, 680, 2, 6720, 6884, 3, 2, 2, 2, 6721, 6722, 7, 140, 2, 2, 6722, 6723, 7, 177, 2, 2, 6723, 6724, 5, 1330, 666, 2, 6724, 6725, 7, 275, 2, 2, 6725, 6726, 7, 96, 2, 2, 6726, 6727, 5, 1358, 680, 2, 6727, 6884, 3, 2, 2, 2, 6728, 6729, 7, 140, 2, 2, 6729, 6730, 7, 191, 2, 2, 6730, 6731, 5, 526, 264, 2, 6731, 6732, 7, 275, 2, 2, 6732, 6733, 7, 96, 2, 2, 6733, 6734, 5, 1358, 680, 2, 6734, 6884, 3, 2, 2, 2, 6735, 6736, 7, 140, 2, 2, 6736, 6737, 7, 213, 2, 2, 6737, 6738, 5, 628, 315, 2, 6738, 6739, 7, 275, 2, 2, 6739, 6740, 7, 96, 2, 2, 6740, 6741, 5, 1358, 680, 2, 6741, 6884, 3, 2, 2, 2, 6742, 6743, 7, 140, 2, 2, 6743, 6744, 5, 310, 156, 2, 6744, 6745, 7, 240, 2, 2, 6745, 6746, 5, 1330, 666, 2, 6746, 6747, 7, 275, 2, 2, 6747, 6748, 7, 96, 2, 2, 6748, 6749, 5, 1358, 680, 2, 6749, 6884, 3, 2, 2, 2, 6750, 6751, 7, 140, 2, 2, 6751, 6752, 7, 241, 2, 2, 6752, 6753, 7, 267, 2, 2, 6753, 6754, 5, 294, 148, 2, 6754, 6755, 7, 275, 2, 2, 6755, 6756, 7, 96, 2, 2, 6756, 6757, 5, 1358, 680, 2, 6757, 6884, 3, 2, 2, 2, 6758, 6759, 7, 140, 2, 2, 6759, 6760, 7, 271, 2, 2, 6760, 6761, 5, 690, 346, 2, 6761, 6762, 7, 275, 2, 2, 6762, 6763, 7, 96, 2, 2, 6763, 6764, 5, 1358, 680, 2, 6764, 6884, 3, 2, 2, 2, 6765, 6766, 7, 140, 2, 2, 6766, 6767, 7, 271, 2, 2, 6767, 6768, 7, 158, 2, 2, 6768, 6769, 5, 526, 264, 2, 6769, 6770, 7, 102, 2, 2, 6770, 6771, 5, 1330, 666, 2, 6771, 6772, 7, 275, 2, 2, 6772, 6773, 7, 96, 2, 2, 6773, 6774, 5, 1358, 680, 2, 6774, 6884, 3, 2, 2, 2, 6775, 6776, 7, 140, 2, 2, 6776, 6777, 7, 271, 2, 2, 6777, 6778, 7, 208, 2, 2, 6778, 6779, 5, 526, 264, 2, 6779, 6780, 7, 102, 2, 2, 6780, 6781, 5, 1330, 666, 2, 6781, 6782, 7, 275, 2, 2, 6782, 6783, 7, 96, 2, 2, 6783, 6784, 5, 1358, 680, 2, 6784, 6884, 3, 2, 2, 2, 6785, 6786, 7, 140, 2, 2, 6786, 6787, 7, 289, 2, 2, 6787, 6788, 5, 628, 315, 2, 6788, 6789, 7, 275, 2, 2, 6789, 6790, 7, 96, 2, 2, 6790, 6791, 5, 1358, 680, 2, 6791, 6884, 3, 2, 2, 2, 6792, 6793, 7, 140, 2, 2, 6793, 6794, 7, 435, 2, 2, 6794, 6795, 5, 628, 315, 2, 6795, 6796, 7, 275, 2, 2, 6796, 6797, 7, 96, 2, 2, 6797, 6798, 5, 1358, 680, 2, 6798, 6884, 3, 2, 2, 2, 6799, 6800, 7, 140, 2, 2, 6800, 6801, 7, 316, 2, 2, 6801, 6802, 5, 1330, 666, 2, 6802, 6803, 7, 275, 2, 2, 6803, 6804, 7, 96, 2, 2, 6804, 6805, 5, 1358, 680, 2, 6805, 6884, 3, 2, 2, 2, 6806, 6807, 7, 140, 2, 2, 6807, 6808, 7, 353, 2, 2, 6808, 6809, 5, 526, 264, 2, 6809, 6810, 7, 275, 2, 2, 6810, 6811, 7, 96, 2, 2, 6811, 6812, 5, 1358, 680, 2, 6812, 6884, 3, 2, 2, 2, 6813, 6814, 7, 140, 2, 2, 6814, 6815, 7, 344, 2, 2, 6815, 6816, 5, 1330, 666, 2, 6816, 6817, 7, 275, 2, 2, 6817, 6818, 7, 96, 2, 2, 6818, 6819, 5, 1358, 680, 2, 6819, 6884, 3, 2, 2, 2, 6820, 6821, 7, 140, 2, 2, 6821, 6822, 7, 335, 2, 2, 6822, 6823, 5, 526, 264, 2, 6823, 6824, 7, 275, 2, 2, 6824, 6825, 7, 96, 2, 2, 6825, 6826, 5, 1358, 680, 2, 6826, 6884, 3, 2, 2, 2, 6827, 6828, 7, 140, 2, 2, 6828, 6829, 7, 348, 2, 2, 6829, 6830, 7, 318, 2, 2, 6830, 6831, 7, 187, 2, 2, 6831, 6832, 5, 526, 264, 2, 6832, 6833, 7, 275, 2, 2, 6833, 6834, 7, 96, 2, 2, 6834, 6835, 5, 1358, 680, 2, 6835, 6884, 3, 2, 2, 2, 6836, 6837, 7, 140, 2, 2, 6837, 6838, 7, 348, 2, 2, 6838, 6839, 7, 318, 2, 2, 6839, 6840, 7, 165, 2, 2, 6840, 6841, 5, 526, 264, 2, 6841, 6842, 7, 275, 2, 2, 6842, 6843, 7, 96, 2, 2, 6843, 6844, 5, 1358, 680, 2, 6844, 6884, 3, 2, 2, 2, 6845, 6846, 7, 140, 2, 2, 6846, 6847, 7, 65, 2, 2, 6847, 6848, 7, 176, 2, 2, 6848, 6849, 7, 374, 2, 2, 6849, 6850, 5, 1330, 666, 2, 6850, 6851, 7, 275, 2, 2, 6851, 6852, 7, 96, 2, 2, 6852, 6853, 5, 1358, 680, 2, 6853, 6884, 3, 2, 2, 2, 6854, 6855, 7, 140, 2, 2, 6855, 6856, 7, 324, 2, 2, 6856, 6857, 5, 1330, 666, 2, 6857, 6858, 7, 275, 2, 2, 6858, 6859, 7, 96, 2, 2, 6859, 6860, 5, 1358, 680, 2, 6860, 6884, 3, 2, 2, 2, 6861, 6862, 7, 140, 2, 2, 6862, 6863, 7, 200, 2, 2, 6863, 6864, 7, 350, 2, 2, 6864, 6865, 5, 1330, 666, 2, 6865, 6866, 7, 275, 2, 2, 6866, 6867, 7, 96, 2, 2, 6867, 6868, 5, 1358, 680, 2, 6868, 6884, 3, 2, 2, 2, 6869, 6870, 7, 140, 2, 2, 6870, 6871, 7, 445, 2, 2, 6871, 6872, 5, 1330, 666, 2, 6872, 6873, 7, 275, 2, 2, 6873, 6874, 7, 96, 2, 2, 6874, 6875, 5, 1358, 680, 2, 6875, 6884, 3, 2, 2, 2, 6876, 6877, 7, 140, 2, 2, 6877, 6878, 7, 444, 2, 2, 6878, 6879, 5, 1330, 666, 2, 6879, 6880, 7, 275, 2, 2, 6880, 6881, 7, 96, 2, 2, 6881, 6882, 5, 1358, 680, 2, 6882, 6884, 3, 2, 2, 2, 6883, 6700, 3, 2, 2, 2, 6883, 6707, 3, 2, 2, 2, 6883, 6714, 3, 2, 2, 2, 6883, 6721, 3, 2, 2, 2, 6883, 6728, 3, 2, 2, 2, 6883, 6735, 3, 2, 2, 2, 6883, 6742, 3, 2, 2, 2, 6883, 6750, 3, 2, 2, 2, 6883, 6758, 3, 2, 2, 2, 6883, 6765, 3, 2, 2, 2, 6883, 6775, 3, 2, 2, 2, 6883, 6785, 3, 2, 2, 2, 6883, 6792, 3, 2, 2, 2, 6883, 6799, 3, 2, 2, 2, 6883, 6806, 3, 2, 2, 2, 6883, 6813, 3, 2, 2, 2, 6883, 6820, 3, 2, 2, 2, 6883, 6827, 3, 2, 2, 2, 6883, 6836, 3, 2, 2, 2, 6883, 6845, 3, 2, 2, 2, 6883, 6854, 3, 2, 2, 2, 6883, 6861, 3, 2, 2, 2, 6883, 6869, 3, 2, 2, 2, 6883, 6876, 3, 2, 2, 2, 6884, 747, 3, 2, 2, 2, 6885, 6886, 7, 48, 2, 2, 6886, 6887, 7, 445, 2, 2, 6887, 6888, 5, 1330, 666, 2, 6888, 6889, 5, 750, 376, 2, 6889, 6890, 5, 666, 334, 2, 6890, 749, 3, 2, 2, 2, 6891, 6894, 5, 752, 377, 2, 6892, 6894, 3, 2, 2, 2, 6893, 6891, 3, 2, 2, 2, 6893, 6892, 3, 2, 2, 2, 6894, 751, 3, 2, 2, 2, 6895, 6896, 7, 64, 2, 2, 6896, 6897, 7, 94, 2, 2, 6897, 6902, 5, 1068, 535, 2, 6898, 6899, 7, 64, 2, 2, 6899, 6900, 7, 32, 2, 2, 6900, 6902, 7, 343, 2, 2, 6901, 6895, 3, 2, 2, 2, 6901, 6898, 3, 2, 2, 2, 6902, 753, 3, 2, 2, 2, 6903, 6904, 7, 140, 2, 2, 6904, 6905, 7, 445, 2, 2, 6905, 6906, 5, 1330, 666, 2, 6906, 6907, 7, 326, 2, 2, 6907, 6908, 5, 462, 232, 2, 6908, 6931, 3, 2, 2, 2, 6909, 6910, 7, 140, 2, 2, 6910, 6911, 7, 445, 2, 2, 6911, 6912, 5, 1330, 666, 2, 6912, 6913, 7, 135, 2, 2, 6913, 6914, 7, 94, 2, 2, 6914, 6915, 5, 1068, 535, 2, 6915, 6931, 3, 2, 2, 2, 6916, 6917, 7, 140, 2, 2, 6917, 6918, 7, 445, 2, 2, 6918, 6919, 5, 1330, 666, 2, 6919, 6920, 7, 326, 2, 2, 6920, 6921, 7, 94, 2, 2, 6921, 6922, 5, 1068, 535, 2, 6922, 6931, 3, 2, 2, 2, 6923, 6924, 7, 140, 2, 2, 6924, 6925, 7, 445, 2, 2, 6925, 6926, 5, 1330, 666, 2, 6926, 6927, 7, 193, 2, 2, 6927, 6928, 7, 94, 2, 2, 6928, 6929, 5, 1068, 535, 2, 6929, 6931, 3, 2, 2, 2, 6930, 6903, 3, 2, 2, 2, 6930, 6909, 3, 2, 2, 2, 6930, 6916, 3, 2, 2, 2, 6930, 6923, 3, 2, 2, 2, 6931, 755, 3, 2, 2, 2, 6932, 6933, 7, 48, 2, 2, 6933, 6934, 7, 444, 2, 2, 6934, 6935, 5, 1330, 666, 2, 6935, 6936, 7, 166, 2, 2, 6936, 6937, 5, 1348, 675, 2, 6937, 6938, 7, 445, 2, 2, 6938, 6939, 5, 758, 380, 2, 6939, 6940, 5, 666, 334, 2, 6940, 757, 3, 2, 2, 2, 6941, 6946, 5, 760, 381, 2, 6942, 6943, 7, 8, 2, 2, 6943, 6945, 5, 760, 381, 2, 6944, 6942, 3, 2, 2, 2, 6945, 6948, 3, 2, 2, 2, 6946, 6944, 3, 2, 2, 2, 6946, 6947, 3, 2, 2, 2, 6947, 759, 3, 2, 2, 2, 6948, 6946, 3, 2, 2, 2, 6949, 6950, 5, 1368, 685, 2, 6950, 761, 3, 2, 2, 2, 6951, 6952, 7, 140, 2, 2, 6952, 6953, 7, 444, 2, 2, 6953, 6954, 5, 1330, 666, 2, 6954, 6955, 7, 326, 2, 2, 6955, 6956, 5, 462, 232, 2, 6956, 6989, 3, 2, 2, 2, 6957, 6958, 7, 140, 2, 2, 6958, 6959, 7, 444, 2, 2, 6959, 6960, 5, 1330, 666, 2, 6960, 6961, 7, 166, 2, 2, 6961, 6962, 5, 1348, 675, 2, 6962, 6989, 3, 2, 2, 2, 6963, 6964, 7, 140, 2, 2, 6964, 6965, 7, 444, 2, 2, 6965, 6966, 5, 1330, 666, 2, 6966, 6967, 7, 298, 2, 2, 6967, 6968, 7, 445, 2, 2, 6968, 6969, 5, 666, 334, 2, 6969, 6989, 3, 2, 2, 2, 6970, 6971, 7, 140, 2, 2, 6971, 6972, 7, 444, 2, 2, 6972, 6973, 5, 1330, 666, 2, 6973, 6974, 7, 326, 2, 2, 6974, 6975, 7, 445, 2, 2, 6975, 6976, 5, 758, 380, 2, 6976, 6977, 5, 666, 334, 2, 6977, 6989, 3, 2, 2, 2, 6978, 6979, 7, 140, 2, 2, 6979, 6980, 7, 444, 2, 2, 6980, 6981, 5, 1330, 666, 2, 6981, 6982, 7, 195, 2, 2, 6982, 6989, 3, 2, 2, 2, 6983, 6984, 7, 140, 2, 2, 6984, 6985, 7, 444, 2, 2, 6985, 6986, 5, 1330, 666, 2, 6986, 6987, 7, 188, 2, 2, 6987, 6989, 3, 2, 2, 2, 6988, 6951, 3, 2, 2, 2, 6988, 6957, 3, 2, 2, 2, 6988, 6963, 3, 2, 2, 2, 6988, 6970, 3, 2, 2, 2, 6988, 6978, 3, 2, 2, 2, 6988, 6983, 3, 2, 2, 2, 6989, 763, 3, 2, 2, 2, 6990, 6991, 7, 193, 2, 2, 6991, 6992, 7, 444, 2, 2, 6992, 6993, 5, 1330, 666, 2, 6993, 6994, 5, 110, 56, 2, 6994, 7003, 3, 2, 2, 2, 6995, 6996, 7, 193, 2, 2, 6996, 6997, 7, 444, 2, 2, 6997, 6998, 7, 222, 2, 2, 6998, 6999, 7, 389, 2, 2, 6999, 7000, 5, 1330, 666, 2, 7000, 7001, 5, 110, 56, 2, 7001, 7003, 3, 2, 2, 2, 7002, 6990, 3, 2, 2, 2, 7002, 6995, 3, 2, 2, 2, 7003, 765, 3, 2, 2, 2, 7004, 7005, 7, 48, 2, 2, 7005, 7006, 5, 620, 311, 2, 7006, 7007, 7, 314, 2, 2, 7007, 7008, 5, 1330, 666, 2, 7008, 7009, 7, 38, 2, 2, 7009, 7010, 7, 82, 2, 2, 7010, 7011, 5, 776, 389, 2, 7011, 7012, 7, 96, 2, 2, 7012, 7013, 5, 1326, 664, 2, 7013, 7014, 5, 1086, 544, 2, 7014, 7015, 7, 59, 2, 2, 7015, 7016, 5, 778, 390, 2, 7016, 7017, 5, 768, 385, 2, 7017, 767, 3, 2, 2, 2, 7018, 7025, 7, 263, 2, 2, 7019, 7025, 5, 772, 387, 2, 7020, 7021, 7, 4, 2, 2, 7021, 7022, 5, 770, 386, 2, 7022, 7023, 7, 5, 2, 2, 7023, 7025, 3, 2, 2, 2, 7024, 7018, 3, 2, 2, 2, 7024, 7019, 3, 2, 2, 2, 7024, 7020, 3, 2, 2, 2, 7025, 769, 3, 2, 2, 2, 7026, 7031, 5, 774, 388, 2, 7027, 7028, 7, 9, 2, 2, 7028, 7030, 5, 774, 388, 2, 7029, 7027, 3, 2, 2, 2, 7030, 7033, 3, 2, 2, 2, 7031, 7029, 3, 2, 2, 2, 7031, 7032, 3, 2, 2, 2, 7032, 771, 3, 2, 2, 2, 7033, 7031, 3, 2, 2, 2, 7034, 7040, 5, 954, 478, 2, 7035, 7040, 5, 904, 453, 2, 7036, 7040, 5, 936, 469, 2, 7037, 7040, 5, 922, 462, 2, 7038, 7040, 5, 780, 391, 2, 7039, 7034, 3, 2, 2, 2, 7039, 7035, 3, 2, 2, 2, 7039, 7036, 3, 2, 2, 2, 7039, 7037, 3, 2, 2, 2, 7039, 7038, 3, 2, 2, 2, 7040, 773, 3, 2, 2, 2, 7041, 7044, 5, 772, 387, 2, 7042, 7044, 3, 2, 2, 2, 7043, 7041, 3, 2, 2, 2, 7043, 7042, 3, 2, 2, 2, 7044, 775, 3, 2, 2, 2, 7045, 7046, 9, 31, 2, 2, 7046, 777, 3, 2, 2, 2, 7047, 7051, 7, 235, 2, 2, 7048, 7051, 7, 139, 2, 2, 7049, 7051, 3, 2, 2, 2, 7050, 7047, 3, 2, 2, 2, 7050, 7048, 3, 2, 2, 2, 7050, 7049, 3, 2, 2, 2, 7051, 779, 3, 2, 2, 2, 7052, 7053, 7, 264, 2, 2, 7053, 7054, 5, 1362, 682, 2, 7054, 7055, 5, 782, 392, 2, 7055, 781, 3, 2, 2, 2, 7056, 7057, 7, 8, 2, 2, 7057, 7060, 5, 1348, 675, 2, 7058, 7060, 3, 2, 2, 2, 7059, 7056, 3, 2, 2, 2, 7059, 7058, 3, 2, 2, 2, 7060, 783, 3, 2, 2, 2, 7061, 7062, 7, 245, 2, 2, 7062, 7063, 5, 1362, 682, 2, 7063, 785, 3, 2, 2, 2, 7064, 7065, 7, 359, 2, 2, 7065, 7069, 5, 1362, 682, 2, 7066, 7067, 7, 359, 2, 2, 7067, 7069, 7, 11, 2, 2, 7068, 7064, 3, 2, 2, 2, 7068, 7066, 3, 2, 2, 2, 7069, 787, 3, 2, 2, 2, 7070, 7071, 7, 131, 2, 2, 7071, 7072, 5, 790, 396, 2, 7072, 7073, 5, 798, 400, 2, 7073, 7121, 3, 2, 2, 2, 7074, 7075, 7, 148, 2, 2, 7075, 7076, 5, 790, 396, 2, 7076, 7077, 5, 796, 399, 2, 7077, 7121, 3, 2, 2, 2, 7078, 7079, 7, 333, 2, 2, 7079, 7080, 7, 349, 2, 2, 7080, 7121, 5, 796, 399, 2, 7081, 7082, 7, 163, 2, 2, 7082, 7083, 5, 790, 396, 2, 7083, 7084, 5, 798, 400, 2, 7084, 7121, 3, 2, 2, 2, 7085, 7086, 7, 447, 2, 2, 7086, 7087, 5, 790, 396, 2, 7087, 7088, 5, 798, 400, 2, 7088, 7121, 3, 2, 2, 2, 7089, 7090, 7, 312, 2, 2, 7090, 7091, 5, 790, 396, 2, 7091, 7092, 5, 798, 400, 2, 7092, 7121, 3, 2, 2, 2, 7093, 7094, 7, 315, 2, 2, 7094, 7121, 5, 1362, 682, 2, 7095, 7096, 7, 301, 2, 2, 7096, 7097, 7, 315, 2, 2, 7097, 7121, 5, 1362, 682, 2, 7098, 7099, 7, 301, 2, 2, 7099, 7121, 5, 1362, 682, 2, 7100, 7101, 7, 312, 2, 2, 7101, 7102, 5, 790, 396, 2, 7102, 7103, 7, 96, 2, 2, 7103, 7104, 7, 315, 2, 2, 7104, 7105, 5, 1362, 682, 2, 7105, 7121, 3, 2, 2, 2, 7106, 7107, 7, 312, 2, 2, 7107, 7108, 5, 790, 396, 2, 7108, 7109, 7, 96, 2, 2, 7109, 7110, 5, 1362, 682, 2, 7110, 7121, 3, 2, 2, 2, 7111, 7112, 7, 283, 2, 2, 7112, 7113, 7, 349, 2, 2, 7113, 7121, 5, 1348, 675, 2, 7114, 7115, 7, 163, 2, 2, 7115, 7116, 7, 284, 2, 2, 7116, 7121, 5, 1348, 675, 2, 7117, 7118, 7, 312, 2, 2, 7118, 7119, 7, 284, 2, 2, 7119, 7121, 5, 1348, 675, 2, 7120, 7070, 3, 2, 2, 2, 7120, 7074, 3, 2, 2, 2, 7120, 7078, 3, 2, 2, 2, 7120, 7081, 3, 2, 2, 2, 7120, 7085, 3, 2, 2, 2, 7120, 7089, 3, 2, 2, 2, 7120, 7093, 3, 2, 2, 2, 7120, 7095, 3, 2, 2, 2, 7120, 7098, 3, 2, 2, 2, 7120, 7100, 3, 2, 2, 2, 7120, 7106, 3, 2, 2, 2, 7120, 7111, 3, 2, 2, 2, 7120, 7114, 3, 2, 2, 2, 7120, 7117, 3, 2, 2, 2, 7121, 789, 3, 2, 2, 2, 7122, 7126, 7, 373, 2, 2, 7123, 7126, 7, 349, 2, 2, 7124, 7126, 3, 2, 2, 2, 7125, 7122, 3, 2, 2, 2, 7125, 7123, 3, 2, 2, 2, 7125, 7124, 3, 2, 2, 2, 7126, 791, 3, 2, 2, 2, 7127, 7128, 7, 237, 2, 2, 7128, 7129, 7, 244, 2, 2, 7129, 7138, 5, 66, 34, 2, 7130, 7131, 7, 293, 2, 2, 7131, 7138, 7, 83, 2, 2, 7132, 7133, 7, 293, 2, 2, 7133, 7138, 7, 375, 2, 2, 7134, 7138, 7, 56, 2, 2, 7135, 7136, 7, 79, 2, 2, 7136, 7138, 7, 56, 2, 2, 7137, 7127, 3, 2, 2, 2, 7137, 7130, 3, 2, 2, 2, 7137, 7132, 3, 2, 2, 2, 7137, 7134, 3, 2, 2, 2, 7137, 7135, 3, 2, 2, 2, 7138, 793, 3, 2, 2, 2, 7139, 7146, 5, 792, 397, 2, 7140, 7142, 7, 8, 2, 2, 7141, 7140, 3, 2, 2, 2, 7141, 7142, 3, 2, 2, 2, 7142, 7143, 3, 2, 2, 2, 7143, 7145, 5, 792, 397, 2, 7144, 7141, 3, 2, 2, 2, 7145, 7148, 3, 2, 2, 2, 7146, 7144, 3, 2, 2, 2, 7146, 7147, 3, 2, 2, 2, 7147, 795, 3, 2, 2, 2, 7148, 7146, 3, 2, 2, 2, 7149, 7152, 5, 794, 398, 2, 7150, 7152, 3, 2, 2, 2, 7151, 7149, 3, 2, 2, 2, 7151, 7150, 3, 2, 2, 2, 7152, 797, 3, 2, 2, 2, 7153, 7155, 7, 35, 2, 2, 7154, 7156, 7, 262, 2, 2, 7155, 7154, 3, 2, 2, 2, 7155, 7156, 3, 2, 2, 2, 7156, 7157, 3, 2, 2, 2, 7157, 7160, 7, 155, 2, 2, 7158, 7160, 3, 2, 2, 2, 7159, 7153, 3, 2, 2, 2, 7159, 7158, 3, 2, 2, 2, 7160, 799, 3, 2, 2, 2, 7161, 7164, 7, 48, 2, 2, 7162, 7163, 7, 84, 2, 2, 7163, 7165, 7, 304, 2, 2, 7164, 7162, 3, 2, 2, 2, 7164, 7165, 3, 2, 2, 2, 7165, 7166, 3, 2, 2, 2, 7166, 7180, 5, 176, 89, 2, 7167, 7168, 7, 369, 2, 2, 7168, 7169, 5, 1326, 664, 2, 7169, 7170, 5, 216, 109, 2, 7170, 7171, 5, 120, 61, 2, 7171, 7181, 3, 2, 2, 2, 7172, 7173, 7, 296, 2, 2, 7173, 7174, 7, 369, 2, 2, 7174, 7175, 5, 1326, 664, 2, 7175, 7176, 7, 4, 2, 2, 7176, 7177, 5, 218, 110, 2, 7177, 7178, 7, 5, 2, 2, 7178, 7179, 5, 120, 61, 2, 7179, 7181, 3, 2, 2, 2, 7180, 7167, 3, 2, 2, 2, 7180, 7172, 3, 2, 2, 2, 7181, 7182, 3, 2, 2, 2, 7182, 7183, 7, 38, 2, 2, 7183, 7184, 5, 954, 478, 2, 7184, 7185, 5, 802, 402, 2, 7185, 801, 3, 2, 2, 2, 7186, 7188, 7, 107, 2, 2, 7187, 7189, 9, 32, 2, 2, 7188, 7187, 3, 2, 2, 2, 7188, 7189, 3, 2, 2, 2, 7189, 7190, 3, 2, 2, 2, 7190, 7191, 7, 44, 2, 2, 7191, 7194, 7, 272, 2, 2, 7192, 7194, 3, 2, 2, 2, 7193, 7186, 3, 2, 2, 2, 7193, 7192, 3, 2, 2, 2, 7194, 803, 3, 2, 2, 2, 7195, 7196, 7, 246, 2, 2, 7196, 7197, 5, 1334, 668, 2, 7197, 805, 3, 2, 2, 2, 7198, 7199, 7, 48, 2, 2, 7199, 7200, 7, 177, 2, 2, 7200, 7201, 5, 1330, 666, 2, 7201, 7202, 5, 18, 10, 2, 7202, 7203, 5, 808, 405, 2, 7203, 807, 3, 2, 2, 2, 7204, 7207, 5, 810, 406, 2, 7205, 7207, 3, 2, 2, 2, 7206, 7204, 3, 2, 2, 2, 7206, 7205, 3, 2, 2, 2, 7207, 809, 3, 2, 2, 2, 7208, 7210, 5, 812, 407, 2, 7209, 7208, 3, 2, 2, 2, 7210, 7211, 3, 2, 2, 2, 7211, 7209, 3, 2, 2, 2, 7211, 7212, 3, 2, 2, 2, 7212, 811, 3, 2, 2, 2, 7213, 7214, 5, 814, 408, 2, 7214, 7218, 5, 816, 409, 2, 7215, 7219, 5, 1354, 678, 2, 7216, 7219, 5, 68, 35, 2, 7217, 7219, 7, 55, 2, 2, 7218, 7215, 3, 2, 2, 2, 7218, 7216, 3, 2, 2, 2, 7218, 7217, 3, 2, 2, 2, 7219, 813, 3, 2, 2, 2, 7220, 7229, 5, 1370, 686, 2, 7221, 7222, 7, 166, 2, 2, 7222, 7229, 7, 76, 2, 2, 7223, 7229, 7, 196, 2, 2, 7224, 7229, 7, 248, 2, 2, 7225, 7229, 7, 275, 2, 2, 7226, 7229, 7, 344, 2, 2, 7227, 7229, 7, 346, 2, 2, 7228, 7220, 3, 2, 2, 2, 7228, 7221, 3, 2, 2, 2, 7228, 7223, 3, 2, 2, 2, 7228, 7224, 3, 2, 2, 2, 7228, 7225, 3, 2, 2, 2, 7228, 7226, 3, 2, 2, 2, 7228, 7227, 3, 2, 2, 2, 7229, 815, 3, 2, 2, 2, 7230, 7233, 7, 12, 2, 2, 7231, 7233, 3, 2, 2, 2, 7232, 7230, 3, 2, 2, 2, 7232, 7231, 3, 2, 2, 2, 7233, 817, 3, 2, 2, 2, 7234, 7235, 7, 140, 2, 2, 7235, 7236, 7, 177, 2, 2, 7236, 7243, 5, 1330, 666, 2, 7237, 7238, 7, 107, 2, 2, 7238, 7244, 5, 808, 405, 2, 7239, 7244, 5, 808, 405, 2, 7240, 7241, 7, 326, 2, 2, 7241, 7242, 7, 344, 2, 2, 7242, 7244, 5, 1330, 666, 2, 7243, 7237, 3, 2, 2, 2, 7243, 7239, 3, 2, 2, 2, 7243, 7240, 3, 2, 2, 2, 7244, 819, 3, 2, 2, 2, 7245, 7246, 7, 140, 2, 2, 7246, 7247, 7, 177, 2, 2, 7247, 7248, 5, 1330, 666, 2, 7248, 7249, 5, 82, 42, 2, 7249, 821, 3, 2, 2, 2, 7250, 7251, 7, 193, 2, 2, 7251, 7254, 7, 177, 2, 2, 7252, 7253, 7, 222, 2, 2, 7253, 7255, 7, 389, 2, 2, 7254, 7252, 3, 2, 2, 2, 7254, 7255, 3, 2, 2, 2, 7255, 7256, 3, 2, 2, 2, 7256, 7262, 5, 1330, 666, 2, 7257, 7258, 5, 18, 10, 2, 7258, 7259, 7, 4, 2, 2, 7259, 7260, 5, 824, 413, 2, 7260, 7261, 7, 5, 2, 2, 7261, 7263, 3, 2, 2, 2, 7262, 7257, 3, 2, 2, 2, 7262, 7263, 3, 2, 2, 2, 7263, 823, 3, 2, 2, 2, 7264, 7269, 5, 826, 414, 2, 7265, 7266, 7, 8, 2, 2, 7266, 7268, 5, 826, 414, 2, 7267, 7265, 3, 2, 2, 2, 7268, 7271, 3, 2, 2, 2, 7269, 7267, 3, 2, 2, 2, 7269, 7270, 3, 2, 2, 2, 7270, 825, 3, 2, 2, 2, 7271, 7269, 3, 2, 2, 2, 7272, 7273, 7, 211, 2, 2, 7273, 827, 3, 2, 2, 2, 7274, 7275, 7, 140, 2, 2, 7275, 7276, 7, 110, 2, 2, 7276, 7277, 5, 526, 264, 2, 7277, 7278, 7, 298, 2, 2, 7278, 7279, 7, 368, 2, 2, 7279, 829, 3, 2, 2, 2, 7280, 7281, 7, 140, 2, 2, 7281, 7282, 7, 342, 2, 2, 7282, 7283, 9, 33, 2, 2, 7283, 7284, 5, 56, 29, 2, 7284, 831, 3, 2, 2, 2, 7285, 7286, 7, 48, 2, 2, 7286, 7287, 7, 191, 2, 2, 7287, 7288, 5, 526, 264, 2, 7288, 7289, 5, 836, 419, 2, 7289, 7290, 5, 1110, 556, 2, 7290, 7291, 5, 194, 98, 2, 7291, 833, 3, 2, 2, 2, 7292, 7293, 7, 140, 2, 2, 7293, 7294, 7, 191, 2, 2, 7294, 7316, 5, 526, 264, 2, 7295, 7317, 5, 108, 55, 2, 7296, 7297, 7, 193, 2, 2, 7297, 7298, 7, 79, 2, 2, 7298, 7317, 7, 80, 2, 2, 7299, 7300, 7, 326, 2, 2, 7300, 7301, 7, 79, 2, 2, 7301, 7317, 7, 80, 2, 2, 7302, 7303, 7, 135, 2, 2, 7303, 7317, 5, 210, 106, 2, 7304, 7305, 7, 193, 2, 2, 7305, 7308, 7, 47, 2, 2, 7306, 7307, 7, 222, 2, 2, 7307, 7309, 7, 389, 2, 2, 7308, 7306, 3, 2, 2, 2, 7308, 7309, 3, 2, 2, 2, 7309, 7310, 3, 2, 2, 2, 7310, 7311, 5, 1330, 666, 2, 7311, 7312, 5, 110, 56, 2, 7312, 7317, 3, 2, 2, 2, 7313, 7314, 7, 365, 2, 2, 7314, 7315, 7, 47, 2, 2, 7315, 7317, 5, 1330, 666, 2, 7316, 7295, 3, 2, 2, 2, 7316, 7296, 3, 2, 2, 2, 7316, 7299, 3, 2, 2, 2, 7316, 7302, 3, 2, 2, 2, 7316, 7304, 3, 2, 2, 2, 7316, 7313, 3, 2, 2, 2, 7317, 835, 3, 2, 2, 2, 7318, 7321, 7, 38, 2, 2, 7319, 7321, 3, 2, 2, 2, 7320, 7318, 3, 2, 2, 2, 7320, 7319, 3, 2, 2, 2, 7321, 837, 3, 2, 2, 2, 7322, 7323, 7, 140, 2, 2, 7323, 7324, 7, 348, 2, 2, 7324, 7325, 7, 318, 2, 2, 7325, 7326, 7, 187, 2, 2, 7326, 7327, 5, 526, 264, 2, 7327, 7328, 5, 462, 232, 2, 7328, 839, 3, 2, 2, 2, 7329, 7330, 7, 140, 2, 2, 7330, 7331, 7, 348, 2, 2, 7331, 7332, 7, 318, 2, 2, 7332, 7333, 7, 165, 2, 2, 7333, 7334, 5, 526, 264, 2, 7334, 7335, 7, 135, 2, 2, 7335, 7336, 7, 250, 2, 2, 7336, 7337, 7, 64, 2, 2, 7337, 7338, 5, 1328, 665, 2, 7338, 7339, 5, 842, 422, 2, 7339, 7340, 5, 524, 263, 2, 7340, 7402, 3, 2, 2, 2, 7341, 7342, 7, 140, 2, 2, 7342, 7343, 7, 348, 2, 2, 7343, 7344, 7, 318, 2, 2, 7344, 7345, 7, 165, 2, 2, 7345, 7346, 5, 526, 264, 2, 7346, 7347, 7, 140, 2, 2, 7347, 7348, 7, 250, 2, 2, 7348, 7349, 7, 64, 2, 2, 7349, 7350, 5, 1328, 665, 2, 7350, 7351, 5, 842, 422, 2, 7351, 7352, 5, 524, 263, 2, 7352, 7402, 3, 2, 2, 2, 7353, 7354, 7, 140, 2, 2, 7354, 7355, 7, 348, 2, 2, 7355, 7356, 7, 318, 2, 2, 7356, 7357, 7, 165, 2, 2, 7357, 7358, 5, 526, 264, 2, 7358, 7359, 7, 140, 2, 2, 7359, 7360, 7, 250, 2, 2, 7360, 7361, 7, 304, 2, 2, 7361, 7362, 5, 526, 264, 2, 7362, 7363, 5, 842, 422, 2, 7363, 7364, 5, 526, 264, 2, 7364, 7402, 3, 2, 2, 2, 7365, 7366, 7, 140, 2, 2, 7366, 7367, 7, 348, 2, 2, 7367, 7368, 7, 318, 2, 2, 7368, 7369, 7, 165, 2, 2, 7369, 7370, 5, 526, 264, 2, 7370, 7371, 7, 140, 2, 2, 7371, 7372, 7, 250, 2, 2, 7372, 7373, 7, 64, 2, 2, 7373, 7374, 5, 1328, 665, 2, 7374, 7375, 7, 304, 2, 2, 7375, 7376, 5, 526, 264, 2, 7376, 7377, 5, 842, 422, 2, 7377, 7378, 5, 526, 264, 2, 7378, 7402, 3, 2, 2, 2, 7379, 7380, 7, 140, 2, 2, 7380, 7381, 7, 348, 2, 2, 7381, 7382, 7, 318, 2, 2, 7382, 7383, 7, 165, 2, 2, 7383, 7384, 5, 526, 264, 2, 7384, 7385, 7, 193, 2, 2, 7385, 7386, 7, 250, 2, 2, 7386, 7387, 7, 64, 2, 2, 7387, 7388, 5, 1328, 665, 2, 7388, 7402, 3, 2, 2, 2, 7389, 7390, 7, 140, 2, 2, 7390, 7391, 7, 348, 2, 2, 7391, 7392, 7, 318, 2, 2, 7392, 7393, 7, 165, 2, 2, 7393, 7394, 5, 526, 264, 2, 7394, 7395, 7, 193, 2, 2, 7395, 7396, 7, 250, 2, 2, 7396, 7397, 7, 222, 2, 2, 7397, 7398, 7, 389, 2, 2, 7398, 7399, 7, 64, 2, 2, 7399, 7400, 5, 1328, 665, 2, 7400, 7402, 3, 2, 2, 2, 7401, 7329, 3, 2, 2, 2, 7401, 7341, 3, 2, 2, 2, 7401, 7353, 3, 2, 2, 2, 7401, 7365, 3, 2, 2, 2, 7401, 7379, 3, 2, 2, 2, 7401, 7389, 3, 2, 2, 2, 7402, 841, 3, 2, 2, 2, 7403, 7404, 7, 107, 2, 2, 7404, 843, 3, 2, 2, 2, 7405, 7406, 7, 48, 2, 2, 7406, 7407, 5, 490, 246, 2, 7407, 7408, 7, 170, 2, 2, 7408, 7409, 5, 526, 264, 2, 7409, 7410, 7, 64, 2, 2, 7410, 7411, 5, 1348, 675, 2, 7411, 7412, 7, 96, 2, 2, 7412, 7413, 5, 1348, 675, 2, 7413, 7414, 7, 66, 2, 2, 7414, 7415, 5, 526, 264, 2, 7415, 845, 3, 2, 2, 2, 7416, 7417, 7, 160, 2, 2, 7417, 7418, 5, 866, 434, 2, 7418, 7419, 5, 1326, 664, 2, 7419, 7420, 5, 848, 425, 2, 7420, 7430, 3, 2, 2, 2, 7421, 7422, 7, 160, 2, 2, 7422, 7430, 5, 866, 434, 2, 7423, 7424, 7, 160, 2, 2, 7424, 7425, 5, 866, 434, 2, 7425, 7426, 5, 1330, 666, 2, 7426, 7427, 7, 82, 2, 2, 7427, 7428, 5, 1326, 664, 2, 7428, 7430, 3, 2, 2, 2, 7429, 7416, 3, 2, 2, 2, 7429, 7421, 3, 2, 2, 2, 7429, 7423, 3, 2, 2, 2, 7430, 847, 3, 2, 2, 2, 7431, 7432, 7, 102, 2, 2, 7432, 7435, 5, 1330, 666, 2, 7433, 7435, 3, 2, 2, 2, 7434, 7431, 3, 2, 2, 2, 7434, 7433, 3, 2, 2, 2, 7435, 849, 3, 2, 2, 2, 7436, 7437, 7, 363, 2, 2, 7437, 7438, 5, 868, 435, 2, 7438, 7439, 5, 870, 436, 2, 7439, 7440, 5, 866, 434, 2, 7440, 7441, 5, 864, 433, 2, 7441, 7442, 5, 878, 440, 2, 7442, 7450, 3, 2, 2, 2, 7443, 7444, 7, 363, 2, 2, 7444, 7445, 7, 4, 2, 2, 7445, 7446, 5, 854, 428, 2, 7446, 7447, 7, 5, 2, 2, 7447, 7448, 5, 878, 440, 2, 7448, 7450, 3, 2, 2, 2, 7449, 7436, 3, 2, 2, 2, 7449, 7443, 3, 2, 2, 2, 7450, 851, 3, 2, 2, 2, 7451, 7452, 5, 856, 429, 2, 7452, 7453, 5, 866, 434, 2, 7453, 7454, 5, 878, 440, 2, 7454, 7462, 3, 2, 2, 2, 7455, 7456, 5, 856, 429, 2, 7456, 7457, 7, 4, 2, 2, 7457, 7458, 5, 854, 428, 2, 7458, 7459, 7, 5, 2, 2, 7459, 7460, 5, 878, 440, 2, 7460, 7462, 3, 2, 2, 2, 7461, 7451, 3, 2, 2, 2, 7461, 7455, 3, 2, 2, 2, 7462, 853, 3, 2, 2, 2, 7463, 7468, 5, 858, 430, 2, 7464, 7465, 7, 8, 2, 2, 7465, 7467, 5, 858, 430, 2, 7466, 7464, 3, 2, 2, 2, 7467, 7470, 3, 2, 2, 2, 7468, 7466, 3, 2, 2, 2, 7468, 7469, 3, 2, 2, 2, 7469, 855, 3, 2, 2, 2, 7470, 7468, 3, 2, 2, 2, 7471, 7472, 9, 34, 2, 2, 7472, 857, 3, 2, 2, 2, 7473, 7474, 5, 860, 431, 2, 7474, 7475, 5, 862, 432, 2, 7475, 859, 3, 2, 2, 2, 7476, 7479, 5, 1366, 684, 2, 7477, 7479, 5, 856, 429, 2, 7478, 7476, 3, 2, 2, 2, 7478, 7477, 3, 2, 2, 2, 7479, 861, 3, 2, 2, 2, 7480, 7484, 5, 68, 35, 2, 7481, 7484, 5, 294, 148, 2, 7482, 7484, 3, 2, 2, 2, 7483, 7480, 3, 2, 2, 2, 7483, 7481, 3, 2, 2, 2, 7483, 7482, 3, 2, 2, 2, 7484, 863, 3, 2, 2, 2, 7485, 7488, 5, 856, 429, 2, 7486, 7488, 3, 2, 2, 2, 7487, 7485, 3, 2, 2, 2, 7487, 7486, 3, 2, 2, 2, 7488, 865, 3, 2, 2, 2, 7489, 7492, 7, 130, 2, 2, 7490, 7492, 3, 2, 2, 2, 7491, 7489, 3, 2, 2, 2, 7491, 7490, 3, 2, 2, 2, 7492, 867, 3, 2, 2, 2, 7493, 7496, 7, 115, 2, 2, 7494, 7496, 3, 2, 2, 2, 7495, 7493, 3, 2, 2, 2, 7495, 7494, 3, 2, 2, 2, 7496, 869, 3, 2, 2, 2, 7497, 7500, 7, 114, 2, 2, 7498, 7500, 3, 2, 2, 2, 7499, 7497, 3, 2, 2, 2, 7499, 7498, 3, 2, 2, 2, 7500, 871, 3, 2, 2, 2, 7501, 7502, 7, 4, 2, 2, 7502, 7503, 5, 1328, 665, 2, 7503, 7504, 7, 5, 2, 2, 7504, 7507, 3, 2, 2, 2, 7505, 7507, 3, 2, 2, 2, 7506, 7501, 3, 2, 2, 2, 7506, 7505, 3, 2, 2, 2, 7507, 873, 3, 2, 2, 2, 7508, 7509, 5, 1326, 664, 2, 7509, 7510, 5, 872, 437, 2, 7510, 875, 3, 2, 2, 2, 7511, 7516, 5, 874, 438, 2, 7512, 7513, 7, 8, 2, 2, 7513, 7515, 5, 874, 438, 2, 7514, 7512, 3, 2, 2, 2, 7515, 7518, 3, 2, 2, 2, 7516, 7514, 3, 2, 2, 2, 7516, 7517, 3, 2, 2, 2, 7517, 877, 3, 2, 2, 2, 7518, 7516, 3, 2, 2, 2, 7519, 7522, 5, 876, 439, 2, 7520, 7522, 3, 2, 2, 2, 7521, 7519, 3, 2, 2, 2, 7521, 7520, 3, 2, 2, 2, 7522, 879, 3, 2, 2, 2, 7523, 7524, 7, 205, 2, 2, 7524, 7540, 5, 882, 442, 2, 7525, 7526, 7, 205, 2, 2, 7526, 7527, 5, 856, 429, 2, 7527, 7528, 5, 866, 434, 2, 7528, 7529, 5, 882, 442, 2, 7529, 7540, 3, 2, 2, 2, 7530, 7531, 7, 205, 2, 2, 7531, 7532, 7, 130, 2, 2, 7532, 7540, 5, 882, 442, 2, 7533, 7534, 7, 205, 2, 2, 7534, 7535, 7, 4, 2, 2, 7535, 7536, 5, 884, 443, 2, 7536, 7537, 7, 5, 2, 2, 7537, 7538, 5, 882, 442, 2, 7538, 7540, 3, 2, 2, 2, 7539, 7523, 3, 2, 2, 2, 7539, 7525, 3, 2, 2, 2, 7539, 7530, 3, 2, 2, 2, 7539, 7533, 3, 2, 2, 2, 7540, 881, 3, 2, 2, 2, 7541, 7551, 5, 954, 478, 2, 7542, 7551, 5, 904, 453, 2, 7543, 7551, 5, 936, 469, 2, 7544, 7551, 5, 922, 462, 2, 7545, 7551, 5, 946, 474, 2, 7546, 7551, 5, 266, 134, 2, 7547, 7551, 5, 272, 137, 2, 7548, 7551, 5, 278, 140, 2, 7549, 7551, 5, 898, 450, 2, 7550, 7541, 3, 2, 2, 2, 7550, 7542, 3, 2, 2, 2, 7550, 7543, 3, 2, 2, 2, 7550, 7544, 3, 2, 2, 2, 7550, 7545, 3, 2, 2, 2, 7550, 7546, 3, 2, 2, 2, 7550, 7547, 3, 2, 2, 2, 7550, 7548, 3, 2, 2, 2, 7550, 7549, 3, 2, 2, 2, 7551, 883, 3, 2, 2, 2, 7552, 7557, 5, 886, 444, 2, 7553, 7554, 7, 8, 2, 2, 7554, 7556, 5, 886, 444, 2, 7555, 7553, 3, 2, 2, 2, 7556, 7559, 3, 2, 2, 2, 7557, 7555, 3, 2, 2, 2, 7557, 7558, 3, 2, 2, 2, 7558, 885, 3, 2, 2, 2, 7559, 7557, 3, 2, 2, 2, 7560, 7561, 5, 888, 445, 2, 7561, 7562, 5, 890, 446, 2, 7562, 887, 3, 2, 2, 2, 7563, 7566, 5, 1366, 684, 2, 7564, 7566, 5, 856, 429, 2, 7565, 7563, 3, 2, 2, 2, 7565, 7564, 3, 2, 2, 2, 7566, 889, 3, 2, 2, 2, 7567, 7571, 5, 68, 35, 2, 7568, 7571, 5, 294, 148, 2, 7569, 7571, 3, 2, 2, 2, 7570, 7567, 3, 2, 2, 2, 7570, 7568, 3, 2, 2, 2, 7570, 7569, 3, 2, 2, 2, 7571, 891, 3, 2, 2, 2, 7572, 7573, 7, 283, 2, 2, 7573, 7574, 5, 1330, 666, 2, 7574, 7575, 5, 894, 448, 2, 7575, 7576, 7, 38, 2, 2, 7576, 7577, 5, 896, 449, 2, 7577, 893, 3, 2, 2, 2, 7578, 7579, 7, 4, 2, 2, 7579, 7580, 5, 1276, 639, 2, 7580, 7581, 7, 5, 2, 2, 7581, 7584, 3, 2, 2, 2, 7582, 7584, 3, 2, 2, 2, 7583, 7578, 3, 2, 2, 2, 7583, 7582, 3, 2, 2, 2, 7584, 895, 3, 2, 2, 2, 7585, 7590, 5, 954, 478, 2, 7586, 7590, 5, 904, 453, 2, 7587, 7590, 5, 936, 469, 2, 7588, 7590, 5, 922, 462, 2, 7589, 7585, 3, 2, 2, 2, 7589, 7586, 3, 2, 2, 2, 7589, 7587, 3, 2, 2, 2, 7589, 7588, 3, 2, 2, 2, 7590, 897, 3, 2, 2, 2, 7591, 7592, 7, 204, 2, 2, 7592, 7593, 5, 1330, 666, 2, 7593, 7594, 5, 900, 451, 2, 7594, 7619, 3, 2, 2, 2, 7595, 7596, 7, 48, 2, 2, 7596, 7597, 5, 176, 89, 2, 7597, 7598, 7, 94, 2, 2, 7598, 7599, 5, 268, 135, 2, 7599, 7600, 7, 38, 2, 2, 7600, 7601, 7, 204, 2, 2, 7601, 7602, 5, 1330, 666, 2, 7602, 7603, 5, 900, 451, 2, 7603, 7604, 5, 270, 136, 2, 7604, 7619, 3, 2, 2, 2, 7605, 7606, 7, 48, 2, 2, 7606, 7607, 5, 176, 89, 2, 7607, 7608, 7, 94, 2, 2, 7608, 7609, 7, 222, 2, 2, 7609, 7610, 7, 79, 2, 2, 7610, 7611, 7, 389, 2, 2, 7611, 7612, 5, 268, 135, 2, 7612, 7613, 7, 38, 2, 2, 7613, 7614, 7, 204, 2, 2, 7614, 7615, 5, 1330, 666, 2, 7615, 7616, 5, 900, 451, 2, 7616, 7617, 5, 270, 136, 2, 7617, 7619, 3, 2, 2, 2, 7618, 7591, 3, 2, 2, 2, 7618, 7595, 3, 2, 2, 2, 7618, 7605, 3, 2, 2, 2, 7619, 899, 3, 2, 2, 2, 7620, 7621, 7, 4, 2, 2, 7621, 7622, 5, 1270, 636, 2, 7622, 7623, 7, 5, 2, 2, 7623, 7626, 3, 2, 2, 2, 7624, 7626, 3, 2, 2, 2, 7625, 7620, 3, 2, 2, 2, 7625, 7624, 3, 2, 2, 2, 7626, 901, 3, 2, 2, 2, 7627, 7628, 7, 179, 2, 2, 7628, 7638, 5, 1330, 666, 2, 7629, 7630, 7, 179, 2, 2, 7630, 7631, 7, 283, 2, 2, 7631, 7638, 5, 1330, 666, 2, 7632, 7633, 7, 179, 2, 2, 7633, 7638, 7, 32, 2, 2, 7634, 7635, 7, 179, 2, 2, 7635, 7636, 7, 283, 2, 2, 7636, 7638, 7, 32, 2, 2, 7637, 7627, 3, 2, 2, 2, 7637, 7629, 3, 2, 2, 2, 7637, 7632, 3, 2, 2, 2, 7637, 7634, 3, 2, 2, 2, 7638, 903, 3, 2, 2, 2, 7639, 7640, 5, 976, 489, 2, 7640, 7641, 7, 234, 2, 2, 7641, 7642, 7, 73, 2, 2, 7642, 7643, 5, 906, 454, 2, 7643, 7644, 5, 908, 455, 2, 7644, 7645, 5, 916, 459, 2, 7645, 7646, 5, 920, 461, 2, 7646, 905, 3, 2, 2, 2, 7647, 7650, 5, 1326, 664, 2, 7648, 7649, 7, 38, 2, 2, 7649, 7651, 5, 1362, 682, 2, 7650, 7648, 3, 2, 2, 2, 7650, 7651, 3, 2, 2, 2, 7651, 907, 3, 2, 2, 2, 7652, 7672, 5, 954, 478, 2, 7653, 7654, 7, 456, 2, 2, 7654, 7655, 5, 910, 456, 2, 7655, 7656, 7, 443, 2, 2, 7656, 7657, 5, 954, 478, 2, 7657, 7672, 3, 2, 2, 2, 7658, 7659, 7, 4, 2, 2, 7659, 7660, 5, 912, 457, 2, 7660, 7665, 7, 5, 2, 2, 7661, 7662, 7, 456, 2, 2, 7662, 7663, 5, 910, 456, 2, 7663, 7664, 7, 443, 2, 2, 7664, 7666, 3, 2, 2, 2, 7665, 7661, 3, 2, 2, 2, 7665, 7666, 3, 2, 2, 2, 7666, 7667, 3, 2, 2, 2, 7667, 7668, 5, 954, 478, 2, 7668, 7672, 3, 2, 2, 2, 7669, 7670, 7, 55, 2, 2, 7670, 7672, 7, 415, 2, 2, 7671, 7652, 3, 2, 2, 2, 7671, 7653, 3, 2, 2, 2, 7671, 7658, 3, 2, 2, 2, 7671, 7669, 3, 2, 2, 2, 7672, 909, 3, 2, 2, 2, 7673, 7674, 9, 35, 2, 2, 7674, 911, 3, 2, 2, 2, 7675, 7680, 5, 914, 458, 2, 7676, 7677, 7, 8, 2, 2, 7677, 7679, 5, 914, 458, 2, 7678, 7676, 3, 2, 2, 2, 7679, 7682, 3, 2, 2, 2, 7680, 7678, 3, 2, 2, 2, 7680, 7681, 3, 2, 2, 2, 7681, 913, 3, 2, 2, 2, 7682, 7680, 3, 2, 2, 2, 7683, 7684, 5, 1362, 682, 2, 7684, 7685, 5, 1316, 659, 2, 7685, 915, 3, 2, 2, 2, 7686, 7687, 7, 82, 2, 2, 7687, 7688, 7, 457, 2, 2, 7688, 7689, 5, 918, 460, 2, 7689, 7696, 7, 59, 2, 2, 7690, 7691, 7, 362, 2, 2, 7691, 7692, 7, 326, 2, 2, 7692, 7693, 5, 938, 470, 2, 7693, 7694, 5, 1086, 544, 2, 7694, 7697, 3, 2, 2, 2, 7695, 7697, 7, 263, 2, 2, 7696, 7690, 3, 2, 2, 2, 7696, 7695, 3, 2, 2, 2, 7697, 7700, 3, 2, 2, 2, 7698, 7700, 3, 2, 2, 2, 7699, 7686, 3, 2, 2, 2, 7699, 7698, 3, 2, 2, 2, 7700, 917, 3, 2, 2, 2, 7701, 7702, 7, 4, 2, 2, 7702, 7703, 5, 600, 301, 2, 7703, 7704, 7, 5, 2, 2, 7704, 7705, 5, 1086, 544, 2, 7705, 7711, 3, 2, 2, 2, 7706, 7707, 7, 82, 2, 2, 7707, 7708, 7, 47, 2, 2, 7708, 7711, 5, 1330, 666, 2, 7709, 7711, 3, 2, 2, 2, 7710, 7701, 3, 2, 2, 2, 7710, 7706, 3, 2, 2, 2, 7710, 7709, 3, 2, 2, 2, 7711, 919, 3, 2, 2, 2, 7712, 7713, 7, 89, 2, 2, 7713, 7716, 5, 1320, 661, 2, 7714, 7716, 3, 2, 2, 2, 7715, 7712, 3, 2, 2, 2, 7715, 7714, 3, 2, 2, 2, 7716, 921, 3, 2, 2, 2, 7717, 7718, 5, 976, 489, 2, 7718, 7719, 7, 184, 2, 2, 7719, 7720, 7, 66, 2, 2, 7720, 7721, 5, 1070, 536, 2, 7721, 7722, 5, 924, 463, 2, 7722, 7723, 5, 1088, 545, 2, 7723, 7724, 5, 920, 461, 2, 7724, 923, 3, 2, 2, 2, 7725, 7726, 7, 102, 2, 2, 7726, 7729, 5, 1052, 527, 2, 7727, 7729, 3, 2, 2, 2, 7728, 7725, 3, 2, 2, 2, 7728, 7727, 3, 2, 2, 2, 7729, 925, 3, 2, 2, 2, 7730, 7731, 7, 249, 2, 2, 7731, 7732, 5, 984, 493, 2, 7732, 7733, 5, 1068, 535, 2, 7733, 7734, 5, 928, 465, 2, 7734, 7735, 5, 932, 467, 2, 7735, 927, 3, 2, 2, 2, 7736, 7737, 7, 70, 2, 2, 7737, 7738, 5, 930, 466, 2, 7738, 7739, 7, 256, 2, 2, 7739, 7742, 3, 2, 2, 2, 7740, 7742, 3, 2, 2, 2, 7741, 7736, 3, 2, 2, 2, 7741, 7740, 3, 2, 2, 2, 7742, 929, 3, 2, 2, 2, 7743, 7744, 7, 133, 2, 2, 7744, 7756, 9, 36, 2, 2, 7745, 7746, 7, 407, 2, 2, 7746, 7756, 9, 36, 2, 2, 7747, 7752, 7, 327, 2, 2, 7748, 7749, 7, 362, 2, 2, 7749, 7753, 7, 203, 2, 2, 7750, 7751, 7, 407, 2, 2, 7751, 7753, 7, 203, 2, 2, 7752, 7748, 3, 2, 2, 2, 7752, 7750, 3, 2, 2, 2, 7752, 7753, 3, 2, 2, 2, 7753, 7756, 3, 2, 2, 2, 7754, 7756, 7, 203, 2, 2, 7755, 7743, 3, 2, 2, 2, 7755, 7745, 3, 2, 2, 2, 7755, 7747, 3, 2, 2, 2, 7755, 7754, 3, 2, 2, 2, 7756, 931, 3, 2, 2, 2, 7757, 7760, 7, 265, 2, 2, 7758, 7760, 3, 2, 2, 2, 7759, 7757, 3, 2, 2, 2, 7759, 7758, 3, 2, 2, 2, 7760, 933, 3, 2, 2, 2, 7761, 7766, 7, 265, 2, 2, 7762, 7763, 7, 458, 2, 2, 7763, 7766, 7, 459, 2, 2, 7764, 7766, 3, 2, 2, 2, 7765, 7761, 3, 2, 2, 2, 7765, 7762, 3, 2, 2, 2, 7765, 7764, 3, 2, 2, 2, 7766, 935, 3, 2, 2, 2, 7767, 7768, 5, 976, 489, 2, 7768, 7769, 7, 362, 2, 2, 7769, 7770, 5, 1070, 536, 2, 7770, 7771, 7, 326, 2, 2, 7771, 7772, 5, 938, 470, 2, 7772, 7773, 5, 1050, 526, 2, 7773, 7774, 5, 1088, 545, 2, 7774, 7775, 5, 920, 461, 2, 7775, 937, 3, 2, 2, 2, 7776, 7781, 5, 940, 471, 2, 7777, 7778, 7, 8, 2, 2, 7778, 7780, 5, 940, 471, 2, 7779, 7777, 3, 2, 2, 2, 7780, 7783, 3, 2, 2, 2, 7781, 7779, 3, 2, 2, 2, 7781, 7782, 3, 2, 2, 2, 7782, 939, 3, 2, 2, 2, 7783, 7781, 3, 2, 2, 2, 7784, 7785, 5, 942, 472, 2, 7785, 7786, 7, 12, 2, 2, 7786, 7787, 5, 1154, 578, 2, 7787, 7795, 3, 2, 2, 2, 7788, 7789, 7, 4, 2, 2, 7789, 7790, 5, 944, 473, 2, 7790, 7791, 7, 5, 2, 2, 7791, 7792, 7, 12, 2, 2, 7792, 7793, 5, 1154, 578, 2, 7793, 7795, 3, 2, 2, 2, 7794, 7784, 3, 2, 2, 2, 7794, 7788, 3, 2, 2, 2, 7795, 941, 3, 2, 2, 2, 7796, 7797, 5, 1362, 682, 2, 7797, 7798, 5, 1316, 659, 2, 7798, 943, 3, 2, 2, 2, 7799, 7804, 5, 942, 472, 2, 7800, 7801, 7, 8, 2, 2, 7801, 7803, 5, 942, 472, 2, 7802, 7800, 3, 2, 2, 2, 7803, 7806, 3, 2, 2, 2, 7804, 7802, 3, 2, 2, 2, 7804, 7805, 3, 2, 2, 2, 7805, 945, 3, 2, 2, 2, 7806, 7804, 3, 2, 2, 2, 7807, 7808, 7, 180, 2, 2, 7808, 7809, 5, 948, 475, 2, 7809, 7810, 5, 950, 476, 2, 7810, 7811, 7, 174, 2, 2, 7811, 7812, 5, 952, 477, 2, 7812, 7813, 7, 64, 2, 2, 7813, 7814, 5, 954, 478, 2, 7814, 947, 3, 2, 2, 2, 7815, 7816, 5, 1330, 666, 2, 7816, 949, 3, 2, 2, 2, 7817, 7818, 7, 262, 2, 2, 7818, 7823, 7, 317, 2, 2, 7819, 7823, 7, 317, 2, 2, 7820, 7823, 7, 109, 2, 2, 7821, 7823, 7, 233, 2, 2, 7822, 7817, 3, 2, 2, 2, 7822, 7819, 3, 2, 2, 2, 7822, 7820, 3, 2, 2, 2, 7822, 7821, 3, 2, 2, 2, 7823, 7826, 3, 2, 2, 2, 7824, 7822, 3, 2, 2, 2, 7824, 7825, 3, 2, 2, 2, 7825, 951, 3, 2, 2, 2, 7826, 7824, 3, 2, 2, 2, 7827, 7833, 3, 2, 2, 2, 7828, 7829, 7, 107, 2, 2, 7829, 7833, 7, 219, 2, 2, 7830, 7831, 7, 372, 2, 2, 7831, 7833, 7, 219, 2, 2, 7832, 7827, 3, 2, 2, 2, 7832, 7828, 3, 2, 2, 2, 7832, 7830, 3, 2, 2, 2, 7833, 953, 3, 2, 2, 2, 7834, 7837, 5, 958, 480, 2, 7835, 7837, 5, 956, 479, 2, 7836, 7834, 3, 2, 2, 2, 7836, 7835, 3, 2, 2, 2, 7837, 955, 3, 2, 2, 2, 7838, 7839, 7, 4, 2, 2, 7839, 7840, 5, 958, 480, 2, 7840, 7841, 7, 5, 2, 2, 7841, 7847, 3, 2, 2, 2, 7842, 7843, 7, 4, 2, 2, 7843, 7844, 5, 956, 479, 2, 7844, 7845, 7, 5, 2, 2, 7845, 7847, 3, 2, 2, 2, 7846, 7838, 3, 2, 2, 2, 7846, 7842, 3, 2, 2, 2, 7847, 957, 3, 2, 2, 2, 7848, 7849, 5, 960, 481, 2, 7849, 7856, 5, 992, 497, 2, 7850, 7851, 5, 1036, 519, 2, 7851, 7852, 5, 1002, 502, 2, 7852, 7857, 3, 2, 2, 2, 7853, 7854, 5, 1000, 501, 2, 7854, 7855, 5, 1038, 520, 2, 7855, 7857, 3, 2, 2, 2, 7856, 7850, 3, 2, 2, 2, 7856, 7853, 3, 2, 2, 2, 7856, 7857, 3, 2, 2, 2, 7857, 7870, 3, 2, 2, 2, 7858, 7859, 5, 968, 485, 2, 7859, 7860, 5, 960, 481, 2, 7860, 7867, 5, 992, 497, 2, 7861, 7862, 5, 1036, 519, 2, 7862, 7863, 5, 1002, 502, 2, 7863, 7868, 3, 2, 2, 2, 7864, 7865, 5, 1000, 501, 2, 7865, 7866, 5, 1038, 520, 2, 7866, 7868, 3, 2, 2, 2, 7867, 7861, 3, 2, 2, 2, 7867, 7864, 3, 2, 2, 2, 7867, 7868, 3, 2, 2, 2, 7868, 7870, 3, 2, 2, 2, 7869, 7848, 3, 2, 2, 2, 7869, 7858, 3, 2, 2, 2, 7870, 959, 3, 2, 2, 2, 7871, 7874, 5, 962, 482, 2, 7872, 7874, 5, 956, 479, 2, 7873, 7871, 3, 2, 2, 2, 7873, 7872, 3, 2, 2, 2, 7874, 961, 3, 2, 2, 2, 7875, 7883, 7, 90, 2, 2, 7876, 7877, 5, 990, 496, 2, 7877, 7878, 5, 978, 490, 2, 7878, 7879, 5, 1318, 660, 2, 7879, 7884, 3, 2, 2, 2, 7880, 7881, 5, 988, 495, 2, 7881, 7882, 5, 1320, 661, 2, 7882, 7884, 3, 2, 2, 2, 7883, 7876, 3, 2, 2, 2, 7883, 7880, 3, 2, 2, 2, 7884, 7885, 3, 2, 2, 2, 7885, 7886, 5, 978, 490, 2, 7886, 7887, 5, 1050, 526, 2, 7887, 7888, 5, 1086, 544, 2, 7888, 7889, 5, 1020, 511, 2, 7889, 7890, 5, 1034, 518, 2, 7890, 7891, 5, 1230, 616, 2, 7891, 7902, 3, 2, 2, 2, 7892, 7902, 5, 1048, 525, 2, 7893, 7894, 7, 94, 2, 2, 7894, 7902, 5, 1066, 534, 2, 7895, 7896, 5, 956, 479, 2, 7896, 7899, 5, 966, 484, 2, 7897, 7900, 5, 962, 482, 2, 7898, 7900, 5, 956, 479, 2, 7899, 7897, 3, 2, 2, 2, 7899, 7898, 3, 2, 2, 2, 7900, 7902, 3, 2, 2, 2, 7901, 7875, 3, 2, 2, 2, 7901, 7892, 3, 2, 2, 2, 7901, 7893, 3, 2, 2, 2, 7901, 7895, 3, 2, 2, 2, 7902, 7910, 3, 2, 2, 2, 7903, 7906, 5, 966, 484, 2, 7904, 7907, 5, 962, 482, 2, 7905, 7907, 5, 956, 479, 2, 7906, 7904, 3, 2, 2, 2, 7906, 7905, 3, 2, 2, 2, 7907, 7909, 3, 2, 2, 2, 7908, 7903, 3, 2, 2, 2, 7909, 7912, 3, 2, 2, 2, 7910, 7908, 3, 2, 2, 2, 7910, 7911, 3, 2, 2, 2, 7911, 963, 3, 2, 2, 2, 7912, 7910, 3, 2, 2, 2, 7913, 7917, 7, 99, 2, 2, 7914, 7917, 7, 72, 2, 2, 7915, 7917, 7, 61, 2, 2, 7916, 7913, 3, 2, 2, 2, 7916, 7914, 3, 2, 2, 2, 7916, 7915, 3, 2, 2, 2, 7917, 965, 3, 2, 2, 2, 7918, 7919, 5, 964, 483, 2, 7919, 7920, 5, 986, 494, 2, 7920, 967, 3, 2, 2, 2, 7921, 7923, 7, 107, 2, 2, 7922, 7924, 7, 296, 2, 2, 7923, 7922, 3, 2, 2, 2, 7923, 7924, 3, 2, 2, 2, 7924, 7925, 3, 2, 2, 2, 7925, 7926, 5, 970, 486, 2, 7926, 969, 3, 2, 2, 2, 7927, 7932, 5, 972, 487, 2, 7928, 7929, 7, 8, 2, 2, 7929, 7931, 5, 972, 487, 2, 7930, 7928, 3, 2, 2, 2, 7931, 7934, 3, 2, 2, 2, 7932, 7930, 3, 2, 2, 2, 7932, 7933, 3, 2, 2, 2, 7933, 971, 3, 2, 2, 2, 7934, 7932, 3, 2, 2, 2, 7935, 7936, 5, 1330, 666, 2, 7936, 7937, 5, 872, 437, 2, 7937, 7938, 7, 38, 2, 2, 7938, 7939, 5, 974, 488, 2, 7939, 7940, 7, 4, 2, 2, 7940, 7941, 5, 896, 449, 2, 7941, 7942, 7, 5, 2, 2, 7942, 973, 3, 2, 2, 2, 7943, 7948, 7, 252, 2, 2, 7944, 7945, 7, 79, 2, 2, 7945, 7948, 7, 252, 2, 2, 7946, 7948, 3, 2, 2, 2, 7947, 7943, 3, 2, 2, 2, 7947, 7944, 3, 2, 2, 2, 7947, 7946, 3, 2, 2, 2, 7948, 975, 3, 2, 2, 2, 7949, 7952, 5, 968, 485, 2, 7950, 7952, 3, 2, 2, 2, 7951, 7949, 3, 2, 2, 2, 7951, 7950, 3, 2, 2, 2, 7952, 977, 3, 2, 2, 2, 7953, 7958, 7, 73, 2, 2, 7954, 7955, 5, 980, 491, 2, 7955, 7956, 5, 982, 492, 2, 7956, 7959, 3, 2, 2, 2, 7957, 7959, 5, 1552, 777, 2, 7958, 7954, 3, 2, 2, 2, 7958, 7957, 3, 2, 2, 2, 7959, 7962, 3, 2, 2, 2, 7960, 7962, 3, 2, 2, 2, 7961, 7953, 3, 2, 2, 2, 7961, 7960, 3, 2, 2, 2, 7962, 979, 3, 2, 2, 2, 7963, 7966, 3, 2, 2, 2, 7964, 7966, 7, 339, 2, 2, 7965, 7963, 3, 2, 2, 2, 7965, 7964, 3, 2, 2, 2, 7966, 981, 3, 2, 2, 2, 7967, 7969, 9, 37, 2, 2, 7968, 7967, 3, 2, 2, 2, 7968, 7969, 3, 2, 2, 2, 7969, 7970, 3, 2, 2, 2, 7970, 7971, 9, 13, 2, 2, 7971, 7972, 5, 984, 493, 2, 7972, 7973, 5, 1326, 664, 2, 7973, 7982, 3, 2, 2, 2, 7974, 7975, 7, 360, 2, 2, 7975, 7976, 5, 984, 493, 2, 7976, 7977, 5, 1326, 664, 2, 7977, 7982, 3, 2, 2, 2, 7978, 7979, 7, 94, 2, 2, 7979, 7982, 5, 1326, 664, 2, 7980, 7982, 5, 1326, 664, 2, 7981, 7968, 3, 2, 2, 2, 7981, 7974, 3, 2, 2, 2, 7981, 7978, 3, 2, 2, 2, 7981, 7980, 3, 2, 2, 2, 7982, 983, 3, 2, 2, 2, 7983, 7986, 7, 94, 2, 2, 7984, 7986, 3, 2, 2, 2, 7985, 7983, 3, 2, 2, 2, 7985, 7984, 3, 2, 2, 2, 7986, 985, 3, 2, 2, 2, 7987, 7991, 7, 32, 2, 2, 7988, 7991, 7, 58, 2, 2, 7989, 7991, 3, 2, 2, 2, 7990, 7987, 3, 2, 2, 2, 7990, 7988, 3, 2, 2, 2, 7990, 7989, 3, 2, 2, 2, 7991, 987, 3, 2, 2, 2, 7992, 7998, 7, 58, 2, 2, 7993, 7994, 7, 82, 2, 2, 7994, 7995, 7, 4, 2, 2, 7995, 7996, 5, 1270, 636, 2, 7996, 7997, 7, 5, 2, 2, 7997, 7999, 3, 2, 2, 2, 7998, 7993, 3, 2, 2, 2, 7998, 7999, 3, 2, 2, 2, 7999, 989, 3, 2, 2, 2, 8000, 8003, 7, 32, 2, 2, 8001, 8003, 3, 2, 2, 2, 8002, 8000, 3, 2, 2, 2, 8002, 8001, 3, 2, 2, 2, 8003, 991, 3, 2, 2, 2, 8004, 8007, 5, 994, 498, 2, 8005, 8007, 3, 2, 2, 2, 8006, 8004, 3, 2, 2, 2, 8006, 8005, 3, 2, 2, 2, 8007, 993, 3, 2, 2, 2, 8008, 8009, 7, 85, 2, 2, 8009, 8010, 7, 149, 2, 2, 8010, 8011, 5, 996, 499, 2, 8011, 995, 3, 2, 2, 2, 8012, 8017, 5, 998, 500, 2, 8013, 8014, 7, 8, 2, 2, 8014, 8016, 5, 998, 500, 2, 8015, 8013, 3, 2, 2, 2, 8016, 8019, 3, 2, 2, 2, 8017, 8015, 3, 2, 2, 2, 8017, 8018, 3, 2, 2, 2, 8018, 997, 3, 2, 2, 2, 8019, 8017, 3, 2, 2, 2, 8020, 8024, 5, 1154, 578, 2, 8021, 8022, 7, 102, 2, 2, 8022, 8025, 5, 1266, 634, 2, 8023, 8025, 5, 614, 308, 2, 8024, 8021, 3, 2, 2, 2, 8024, 8023, 3, 2, 2, 2, 8025, 8026, 3, 2, 2, 2, 8026, 8027, 5, 616, 309, 2, 8027, 999, 3, 2, 2, 2, 8028, 8030, 5, 1004, 503, 2, 8029, 8031, 5, 1006, 504, 2, 8030, 8029, 3, 2, 2, 2, 8030, 8031, 3, 2, 2, 2, 8031, 8037, 3, 2, 2, 2, 8032, 8034, 5, 1006, 504, 2, 8033, 8035, 5, 1004, 503, 2, 8034, 8033, 3, 2, 2, 2, 8034, 8035, 3, 2, 2, 2, 8035, 8037, 3, 2, 2, 2, 8036, 8028, 3, 2, 2, 2, 8036, 8032, 3, 2, 2, 2, 8037, 1001, 3, 2, 2, 2, 8038, 8041, 5, 1000, 501, 2, 8039, 8041, 3, 2, 2, 2, 8040, 8038, 3, 2, 2, 2, 8040, 8039, 3, 2, 2, 2, 8041, 1003, 3, 2, 2, 2, 8042, 8043, 7, 76, 2, 2, 8043, 8046, 5, 1008, 505, 2, 8044, 8045, 7, 8, 2, 2, 8045, 8047, 5, 1010, 506, 2, 8046, 8044, 3, 2, 2, 2, 8046, 8047, 3, 2, 2, 2, 8047, 8066, 3, 2, 2, 2, 8048, 8049, 7, 63, 2, 2, 8049, 8063, 5, 1018, 510, 2, 8050, 8051, 5, 1012, 507, 2, 8051, 8055, 5, 1016, 509, 2, 8052, 8056, 7, 83, 2, 2, 8053, 8054, 7, 107, 2, 2, 8054, 8056, 7, 460, 2, 2, 8055, 8052, 3, 2, 2, 2, 8055, 8053, 3, 2, 2, 2, 8056, 8064, 3, 2, 2, 2, 8057, 8061, 5, 1016, 509, 2, 8058, 8062, 7, 83, 2, 2, 8059, 8060, 7, 107, 2, 2, 8060, 8062, 7, 460, 2, 2, 8061, 8058, 3, 2, 2, 2, 8061, 8059, 3, 2, 2, 2, 8062, 8064, 3, 2, 2, 2, 8063, 8050, 3, 2, 2, 2, 8063, 8057, 3, 2, 2, 2, 8064, 8066, 3, 2, 2, 2, 8065, 8042, 3, 2, 2, 2, 8065, 8048, 3, 2, 2, 2, 8066, 1005, 3, 2, 2, 2, 8067, 8072, 7, 81, 2, 2, 8068, 8073, 5, 1010, 506, 2, 8069, 8070, 5, 1012, 507, 2, 8070, 8071, 5, 1016, 509, 2, 8071, 8073, 3, 2, 2, 2, 8072, 8068, 3, 2, 2, 2, 8072, 8069, 3, 2, 2, 2, 8073, 1007, 3, 2, 2, 2, 8074, 8077, 5, 1154, 578, 2, 8075, 8077, 7, 32, 2, 2, 8076, 8074, 3, 2, 2, 2, 8076, 8075, 3, 2, 2, 2, 8077, 1009, 3, 2, 2, 2, 8078, 8079, 5, 1154, 578, 2, 8079, 1011, 3, 2, 2, 2, 8080, 8086, 5, 1196, 599, 2, 8081, 8082, 7, 14, 2, 2, 8082, 8086, 5, 1014, 508, 2, 8083, 8084, 7, 15, 2, 2, 8084, 8086, 5, 1014, 508, 2, 8085, 8080, 3, 2, 2, 2, 8085, 8081, 3, 2, 2, 2, 8085, 8083, 3, 2, 2, 2, 8086, 1013, 3, 2, 2, 2, 8087, 8090, 5, 1346, 674, 2, 8088, 8090, 5, 1344, 673, 2, 8089, 8087, 3, 2, 2, 2, 8089, 8088, 3, 2, 2, 2, 8090, 1015, 3, 2, 2, 2, 8091, 8092, 9, 38, 2, 2, 8092, 1017, 3, 2, 2, 2, 8093, 8094, 9, 39, 2, 2, 8094, 1019, 3, 2, 2, 2, 8095, 8096, 7, 68, 2, 2, 8096, 8097, 7, 149, 2, 2, 8097, 8100, 5, 1022, 512, 2, 8098, 8100, 3, 2, 2, 2, 8099, 8095, 3, 2, 2, 2, 8099, 8098, 3, 2, 2, 2, 8100, 1021, 3, 2, 2, 2, 8101, 8106, 5, 1024, 513, 2, 8102, 8103, 7, 8, 2, 2, 8103, 8105, 5, 1024, 513, 2, 8104, 8102, 3, 2, 2, 2, 8105, 8108, 3, 2, 2, 2, 8106, 8104, 3, 2, 2, 2, 8106, 8107, 3, 2, 2, 2, 8107, 1023, 3, 2, 2, 2, 8108, 8106, 3, 2, 2, 2, 8109, 8115, 5, 1154, 578, 2, 8110, 8115, 5, 1026, 514, 2, 8111, 8115, 5, 1030, 516, 2, 8112, 8115, 5, 1028, 515, 2, 8113, 8115, 5, 1032, 517, 2, 8114, 8109, 3, 2, 2, 2, 8114, 8110, 3, 2, 2, 2, 8114, 8111, 3, 2, 2, 2, 8114, 8112, 3, 2, 2, 2, 8114, 8113, 3, 2, 2, 2, 8115, 1025, 3, 2, 2, 2, 8116, 8117, 7, 4, 2, 2, 8117, 8118, 7, 5, 2, 2, 8118, 1027, 3, 2, 2, 2, 8119, 8120, 7, 461, 2, 2, 8120, 8121, 7, 4, 2, 2, 8121, 8122, 5, 1270, 636, 2, 8122, 8123, 7, 5, 2, 2, 8123, 1029, 3, 2, 2, 2, 8124, 8125, 7, 462, 2, 2, 8125, 8126, 7, 4, 2, 2, 8126, 8127, 5, 1270, 636, 2, 8127, 8128, 7, 5, 2, 2, 8128, 1031, 3, 2, 2, 2, 8129, 8130, 7, 463, 2, 2, 8130, 8131, 7, 464, 2, 2, 8131, 8132, 7, 4, 2, 2, 8132, 8133, 5, 1022, 512, 2, 8133, 8134, 7, 5, 2, 2, 8134, 1033, 3, 2, 2, 2, 8135, 8136, 7, 69, 2, 2, 8136, 8139, 5, 1154, 578, 2, 8137, 8139, 3, 2, 2, 2, 8138, 8135, 3, 2, 2, 2, 8138, 8137, 3, 2, 2, 2, 8139, 1035, 3, 2, 2, 2, 8140, 8145, 5, 1040, 521, 2, 8141, 8142, 7, 64, 2, 2, 8142, 8143, 7, 293, 2, 2, 8143, 8145, 7, 83, 2, 2, 8144, 8140, 3, 2, 2, 2, 8144, 8141, 3, 2, 2, 2, 8145, 1037, 3, 2, 2, 2, 8146, 8149, 5, 1036, 519, 2, 8147, 8149, 3, 2, 2, 2, 8148, 8146, 3, 2, 2, 2, 8148, 8147, 3, 2, 2, 2, 8149, 1039, 3, 2, 2, 2, 8150, 8152, 5, 1042, 522, 2, 8151, 8150, 3, 2, 2, 2, 8152, 8153, 3, 2, 2, 2, 8153, 8151, 3, 2, 2, 2, 8153, 8154, 3, 2, 2, 2, 8154, 1041, 3, 2, 2, 2, 8155, 8156, 5, 1044, 523, 2, 8156, 8157, 5, 1046, 524, 2, 8157, 8158, 5, 934, 468, 2, 8158, 1043, 3, 2, 2, 2, 8159, 8169, 7, 64, 2, 2, 8160, 8161, 7, 262, 2, 2, 8161, 8163, 7, 238, 2, 2, 8162, 8160, 3, 2, 2, 2, 8162, 8163, 3, 2, 2, 2, 8163, 8164, 3, 2, 2, 2, 8164, 8170, 7, 362, 2, 2, 8165, 8167, 7, 238, 2, 2, 8166, 8165, 3, 2, 2, 2, 8166, 8167, 3, 2, 2, 2, 8167, 8168, 3, 2, 2, 2, 8168, 8170, 7, 327, 2, 2, 8169, 8162, 3, 2, 2, 2, 8169, 8166, 3, 2, 2, 2, 8170, 1045, 3, 2, 2, 2, 8171, 8172, 7, 268, 2, 2, 8172, 8175, 5, 1324, 663, 2, 8173, 8175, 3, 2, 2, 2, 8174, 8171, 3, 2, 2, 2, 8174, 8173, 3, 2, 2, 2, 8175, 1047, 3, 2, 2, 2, 8176, 8177, 7, 415, 2, 2, 8177, 8178, 7, 4, 2, 2, 8178, 8179, 5, 1270, 636, 2, 8179, 8187, 7, 5, 2, 2, 8180, 8181, 7, 8, 2, 2, 8181, 8182, 7, 4, 2, 2, 8182, 8183, 5, 1270, 636, 2, 8183, 8184, 7, 5, 2, 2, 8184, 8186, 3, 2, 2, 2, 8185, 8180, 3, 2, 2, 2, 8186, 8189, 3, 2, 2, 2, 8187, 8185, 3, 2, 2, 2, 8187, 8188, 3, 2, 2, 2, 8188, 1049, 3, 2, 2, 2, 8189, 8187, 3, 2, 2, 2, 8190, 8191, 7, 66, 2, 2, 8191, 8194, 5, 1052, 527, 2, 8192, 8194, 3, 2, 2, 2, 8193, 8190, 3, 2, 2, 2, 8193, 8192, 3, 2, 2, 2, 8194, 1051, 3, 2, 2, 2, 8195, 8200, 5, 1054, 528, 2, 8196, 8197, 7, 8, 2, 2, 8197, 8199, 5, 1054, 528, 2, 8198, 8196, 3, 2, 2, 2, 8199, 8202, 3, 2, 2, 2, 8200, 8198, 3, 2, 2, 2, 8200, 8201, 3, 2, 2, 2, 8201, 1053, 3, 2, 2, 2, 8202, 8200, 3, 2, 2, 2, 8203, 8204, 5, 1066, 534, 2, 8204, 8206, 5, 1058, 530, 2, 8205, 8207, 5, 1072, 537, 2, 8206, 8205, 3, 2, 2, 2, 8206, 8207, 3, 2, 2, 2, 8207, 8253, 3, 2, 2, 2, 8208, 8209, 5, 1076, 539, 2, 8209, 8210, 5, 1060, 531, 2, 8210, 8253, 3, 2, 2, 2, 8211, 8212, 5, 1096, 549, 2, 8212, 8213, 5, 1058, 530, 2, 8213, 8253, 3, 2, 2, 2, 8214, 8215, 5, 956, 479, 2, 8215, 8216, 5, 1058, 530, 2, 8216, 8253, 3, 2, 2, 2, 8217, 8227, 7, 74, 2, 2, 8218, 8219, 5, 1096, 549, 2, 8219, 8220, 5, 1058, 530, 2, 8220, 8228, 3, 2, 2, 2, 8221, 8222, 5, 1076, 539, 2, 8222, 8223, 5, 1060, 531, 2, 8223, 8228, 3, 2, 2, 2, 8224, 8225, 5, 956, 479, 2, 8225, 8226, 5, 1058, 530, 2, 8226, 8228, 3, 2, 2, 2, 8227, 8218, 3, 2, 2, 2, 8227, 8221, 3, 2, 2, 2, 8227, 8224, 3, 2, 2, 2, 8228, 8253, 3, 2, 2, 2, 8229, 8230, 7, 4, 2, 2, 8230, 8247, 5, 1054, 528, 2, 8231, 8232, 7, 112, 2, 2, 8232, 8233, 7, 120, 2, 2, 8233, 8248, 5, 1054, 528, 2, 8234, 8236, 7, 123, 2, 2, 8235, 8237, 5, 1062, 532, 2, 8236, 8235, 3, 2, 2, 2, 8236, 8237, 3, 2, 2, 2, 8237, 8238, 3, 2, 2, 2, 8238, 8239, 7, 120, 2, 2, 8239, 8248, 5, 1054, 528, 2, 8240, 8242, 5, 1062, 532, 2, 8241, 8240, 3, 2, 2, 2, 8241, 8242, 3, 2, 2, 2, 8242, 8243, 3, 2, 2, 2, 8243, 8244, 7, 120, 2, 2, 8244, 8245, 5, 1054, 528, 2, 8245, 8246, 5, 1064, 533, 2, 8246, 8248, 3, 2, 2, 2, 8247, 8231, 3, 2, 2, 2, 8247, 8234, 3, 2, 2, 2, 8247, 8241, 3, 2, 2, 2, 8247, 8248, 3, 2, 2, 2, 8248, 8249, 3, 2, 2, 2, 8249, 8250, 7, 5, 2, 2, 8250, 8251, 5, 1058, 530, 2, 8251, 8253, 3, 2, 2, 2, 8252, 8203, 3, 2, 2, 2, 8252, 8208, 3, 2, 2, 2, 8252, 8211, 3, 2, 2, 2, 8252, 8214, 3, 2, 2, 2, 8252, 8217, 3, 2, 2, 2, 8252, 8229, 3, 2, 2, 2, 8253, 8272, 3, 2, 2, 2, 8254, 8255, 7, 112, 2, 2, 8255, 8256, 7, 120, 2, 2, 8256, 8271, 5, 1054, 528, 2, 8257, 8259, 7, 123, 2, 2, 8258, 8260, 5, 1062, 532, 2, 8259, 8258, 3, 2, 2, 2, 8259, 8260, 3, 2, 2, 2, 8260, 8261, 3, 2, 2, 2, 8261, 8262, 7, 120, 2, 2, 8262, 8271, 5, 1054, 528, 2, 8263, 8265, 5, 1062, 532, 2, 8264, 8263, 3, 2, 2, 2, 8264, 8265, 3, 2, 2, 2, 8265, 8266, 3, 2, 2, 2, 8266, 8267, 7, 120, 2, 2, 8267, 8268, 5, 1054, 528, 2, 8268, 8269, 5, 1064, 533, 2, 8269, 8271, 3, 2, 2, 2, 8270, 8254, 3, 2, 2, 2, 8270, 8257, 3, 2, 2, 2, 8270, 8264, 3, 2, 2, 2, 8271, 8274, 3, 2, 2, 2, 8272, 8270, 3, 2, 2, 2, 8272, 8273, 3, 2, 2, 2, 8273, 1055, 3, 2, 2, 2, 8274, 8272, 3, 2, 2, 2, 8275, 8277, 7, 38, 2, 2, 8276, 8275, 3, 2, 2, 2, 8276, 8277, 3, 2, 2, 2, 8277, 8278, 3, 2, 2, 2, 8278, 8283, 5, 1362, 682, 2, 8279, 8280, 7, 4, 2, 2, 8280, 8281, 5, 1328, 665, 2, 8281, 8282, 7, 5, 2, 2, 8282, 8284, 3, 2, 2, 2, 8283, 8279, 3, 2, 2, 2, 8283, 8284, 3, 2, 2, 2, 8284, 1057, 3, 2, 2, 2, 8285, 8288, 5, 1056, 529, 2, 8286, 8288, 3, 2, 2, 2, 8287, 8285, 3, 2, 2, 2, 8287, 8286, 3, 2, 2, 2, 8288, 1059, 3, 2, 2, 2, 8289, 8303, 5, 1056, 529, 2, 8290, 8292, 7, 38, 2, 2, 8291, 8293, 5, 1362, 682, 2, 8292, 8291, 3, 2, 2, 2, 8292, 8293, 3, 2, 2, 2, 8293, 8296, 3, 2, 2, 2, 8294, 8296, 5, 1362, 682, 2, 8295, 8290, 3, 2, 2, 2, 8295, 8294, 3, 2, 2, 2, 8296, 8297, 3, 2, 2, 2, 8297, 8298, 7, 4, 2, 2, 8298, 8299, 5, 1092, 547, 2, 8299, 8300, 7, 5, 2, 2, 8300, 8303, 3, 2, 2, 2, 8301, 8303, 3, 2, 2, 2, 8302, 8289, 3, 2, 2, 2, 8302, 8295, 3, 2, 2, 2, 8302, 8301, 3, 2, 2, 2, 8303, 1061, 3, 2, 2, 2, 8304, 8306, 9, 40, 2, 2, 8305, 8307, 7, 125, 2, 2, 8306, 8305, 3, 2, 2, 2, 8306, 8307, 3, 2, 2, 2, 8307, 1063, 3, 2, 2, 2, 8308, 8309, 7, 102, 2, 2, 8309, 8310, 7, 4, 2, 2, 8310, 8311, 5, 1328, 665, 2, 8311, 8312, 7, 5, 2, 2, 8312, 8316, 3, 2, 2, 2, 8313, 8314, 7, 82, 2, 2, 8314, 8316, 5, 1154, 578, 2, 8315, 8308, 3, 2, 2, 2, 8315, 8313, 3, 2, 2, 2, 8316, 1065, 3, 2, 2, 2, 8317, 8319, 5, 1326, 664, 2, 8318, 8320, 7, 11, 2, 2, 8319, 8318, 3, 2, 2, 2, 8319, 8320, 3, 2, 2, 2, 8320, 8330, 3, 2, 2, 2, 8321, 8327, 7, 83, 2, 2, 8322, 8328, 5, 1326, 664, 2, 8323, 8324, 7, 4, 2, 2, 8324, 8325, 5, 1326, 664, 2, 8325, 8326, 7, 5, 2, 2, 8326, 8328, 3, 2, 2, 2, 8327, 8322, 3, 2, 2, 2, 8327, 8323, 3, 2, 2, 2, 8328, 8330, 3, 2, 2, 2, 8329, 8317, 3, 2, 2, 2, 8329, 8321, 3, 2, 2, 2, 8330, 1067, 3, 2, 2, 2, 8331, 8336, 5, 1066, 534, 2, 8332, 8333, 7, 8, 2, 2, 8333, 8335, 5, 1066, 534, 2, 8334, 8332, 3, 2, 2, 2, 8335, 8338, 3, 2, 2, 2, 8336, 8334, 3, 2, 2, 2, 8336, 8337, 3, 2, 2, 2, 8337, 1069, 3, 2, 2, 2, 8338, 8336, 3, 2, 2, 2, 8339, 8344, 5, 1066, 534, 2, 8340, 8342, 7, 38, 2, 2, 8341, 8340, 3, 2, 2, 2, 8341, 8342, 3, 2, 2, 2, 8342, 8343, 3, 2, 2, 2, 8343, 8345, 5, 1362, 682, 2, 8344, 8341, 3, 2, 2, 2, 8344, 8345, 3, 2, 2, 2, 8345, 1071, 3, 2, 2, 2, 8346, 8347, 7, 465, 2, 2, 8347, 8348, 5, 1336, 669, 2, 8348, 8349, 7, 4, 2, 2, 8349, 8350, 5, 1270, 636, 2, 8350, 8351, 7, 5, 2, 2, 8351, 8352, 5, 1074, 538, 2, 8352, 1073, 3, 2, 2, 2, 8353, 8354, 7, 303, 2, 2, 8354, 8355, 7, 4, 2, 2, 8355, 8356, 5, 1154, 578, 2, 8356, 8357, 7, 5, 2, 2, 8357, 8360, 3, 2, 2, 2, 8358, 8360, 3, 2, 2, 2, 8359, 8353, 3, 2, 2, 2, 8359, 8358, 3, 2, 2, 2, 8360, 1075, 3, 2, 2, 2, 8361, 8362, 5, 1204, 603, 2, 8362, 8363, 5, 1084, 543, 2, 8363, 8372, 3, 2, 2, 2, 8364, 8365, 7, 313, 2, 2, 8365, 8366, 7, 66, 2, 2, 8366, 8367, 7, 4, 2, 2, 8367, 8368, 5, 1080, 541, 2, 8368, 8369, 7, 5, 2, 2, 8369, 8370, 5, 1084, 543, 2, 8370, 8372, 3, 2, 2, 2, 8371, 8361, 3, 2, 2, 2, 8371, 8364, 3, 2, 2, 2, 8372, 1077, 3, 2, 2, 2, 8373, 8374, 5, 1204, 603, 2, 8374, 8375, 5, 1082, 542, 2, 8375, 1079, 3, 2, 2, 2, 8376, 8381, 5, 1078, 540, 2, 8377, 8378, 7, 8, 2, 2, 8378, 8380, 5, 1078, 540, 2, 8379, 8377, 3, 2, 2, 2, 8380, 8383, 3, 2, 2, 2, 8381, 8379, 3, 2, 2, 2, 8381, 8382, 3, 2, 2, 2, 8382, 1081, 3, 2, 2, 2, 8383, 8381, 3, 2, 2, 2, 8384, 8385, 7, 38, 2, 2, 8385, 8386, 7, 4, 2, 2, 8386, 8387, 5, 1092, 547, 2, 8387, 8388, 7, 5, 2, 2, 8388, 8391, 3, 2, 2, 2, 8389, 8391, 3, 2, 2, 2, 8390, 8384, 3, 2, 2, 2, 8390, 8389, 3, 2, 2, 2, 8391, 1083, 3, 2, 2, 2, 8392, 8393, 7, 107, 2, 2, 8393, 8396, 7, 466, 2, 2, 8394, 8396, 3, 2, 2, 2, 8395, 8392, 3, 2, 2, 2, 8395, 8394, 3, 2, 2, 2, 8396, 1085, 3, 2, 2, 2, 8397, 8398, 7, 105, 2, 2, 8398, 8401, 5, 1154, 578, 2, 8399, 8401, 3, 2, 2, 2, 8400, 8397, 3, 2, 2, 2, 8400, 8399, 3, 2, 2, 2, 8401, 1087, 3, 2, 2, 2, 8402, 8407, 7, 105, 2, 2, 8403, 8404, 7, 427, 2, 2, 8404, 8405, 7, 268, 2, 2, 8405, 8408, 5, 948, 475, 2, 8406, 8408, 5, 1154, 578, 2, 8407, 8403, 3, 2, 2, 2, 8407, 8406, 3, 2, 2, 2, 8408, 8411, 3, 2, 2, 2, 8409, 8411, 3, 2, 2, 2, 8410, 8402, 3, 2, 2, 2, 8410, 8409, 3, 2, 2, 2, 8411, 1089, 3, 2, 2, 2, 8412, 8415, 5, 1092, 547, 2, 8413, 8415, 3, 2, 2, 2, 8414, 8412, 3, 2, 2, 2, 8414, 8413, 3, 2, 2, 2, 8415, 1091, 3, 2, 2, 2, 8416, 8421, 5, 1094, 548, 2, 8417, 8418, 7, 8, 2, 2, 8418, 8420, 5, 1094, 548, 2, 8419, 8417, 3, 2, 2, 2, 8420, 8423, 3, 2, 2, 2, 8421, 8419, 3, 2, 2, 2, 8421, 8422, 3, 2, 2, 2, 8422, 1093, 3, 2, 2, 2, 8423, 8421, 3, 2, 2, 2, 8424, 8425, 5, 1362, 682, 2, 8425, 8426, 5, 1110, 556, 2, 8426, 8427, 5, 112, 57, 2, 8427, 1095, 3, 2, 2, 2, 8428, 8429, 7, 467, 2, 2, 8429, 8445, 7, 4, 2, 2, 8430, 8431, 5, 1196, 599, 2, 8431, 8432, 5, 1222, 612, 2, 8432, 8433, 7, 468, 2, 2, 8433, 8434, 5, 1098, 550, 2, 8434, 8446, 3, 2, 2, 2, 8435, 8436, 7, 469, 2, 2, 8436, 8437, 7, 4, 2, 2, 8437, 8438, 5, 1106, 554, 2, 8438, 8439, 7, 5, 2, 2, 8439, 8440, 7, 8, 2, 2, 8440, 8441, 5, 1196, 599, 2, 8441, 8442, 5, 1222, 612, 2, 8442, 8443, 7, 468, 2, 2, 8443, 8444, 5, 1098, 550, 2, 8444, 8446, 3, 2, 2, 2, 8445, 8430, 3, 2, 2, 2, 8445, 8435, 3, 2, 2, 2, 8446, 8447, 3, 2, 2, 2, 8447, 8448, 7, 5, 2, 2, 8448, 1097, 3, 2, 2, 2, 8449, 8454, 5, 1100, 551, 2, 8450, 8451, 7, 8, 2, 2, 8451, 8453, 5, 1100, 551, 2, 8452, 8450, 3, 2, 2, 2, 8453, 8456, 3, 2, 2, 2, 8454, 8452, 3, 2, 2, 2, 8454, 8455, 3, 2, 2, 2, 8455, 1099, 3, 2, 2, 2, 8456, 8454, 3, 2, 2, 2, 8457, 8464, 5, 1362, 682, 2, 8458, 8460, 5, 1110, 556, 2, 8459, 8461, 5, 1102, 552, 2, 8460, 8459, 3, 2, 2, 2, 8460, 8461, 3, 2, 2, 2, 8461, 8465, 3, 2, 2, 2, 8462, 8463, 7, 64, 2, 2, 8463, 8465, 7, 466, 2, 2, 8464, 8458, 3, 2, 2, 2, 8464, 8462, 3, 2, 2, 2, 8465, 1101, 3, 2, 2, 2, 8466, 8468, 5, 1104, 553, 2, 8467, 8466, 3, 2, 2, 2, 8468, 8469, 3, 2, 2, 2, 8469, 8467, 3, 2, 2, 2, 8469, 8470, 3, 2, 2, 2, 8470, 1103, 3, 2, 2, 2, 8471, 8472, 7, 55, 2, 2, 8472, 8480, 5, 1154, 578, 2, 8473, 8474, 5, 1370, 686, 2, 8474, 8475, 5, 1154, 578, 2, 8475, 8480, 3, 2, 2, 2, 8476, 8477, 7, 79, 2, 2, 8477, 8480, 7, 80, 2, 2, 8478, 8480, 7, 80, 2, 2, 8479, 8471, 3, 2, 2, 2, 8479, 8473, 3, 2, 2, 2, 8479, 8476, 3, 2, 2, 2, 8479, 8478, 3, 2, 2, 2, 8480, 1105, 3, 2, 2, 2, 8481, 8486, 5, 1108, 555, 2, 8482, 8483, 7, 8, 2, 2, 8483, 8485, 5, 1108, 555, 2, 8484, 8482, 3, 2, 2, 2, 8485, 8488, 3, 2, 2, 2, 8486, 8484, 3, 2, 2, 2, 8486, 8487, 3, 2, 2, 2, 8487, 1107, 3, 2, 2, 2, 8488, 8486, 3, 2, 2, 2, 8489, 8490, 5, 1194, 598, 2, 8490, 8491, 7, 38, 2, 2, 8491, 8492, 5, 1368, 685, 2, 8492, 8496, 3, 2, 2, 2, 8493, 8494, 7, 55, 2, 2, 8494, 8496, 5, 1194, 598, 2, 8495, 8489, 3, 2, 2, 2, 8495, 8493, 3, 2, 2, 2, 8496, 1109, 3, 2, 2, 2, 8497, 8499, 7, 408, 2, 2, 8498, 8497, 3, 2, 2, 2, 8498, 8499, 3, 2, 2, 2, 8499, 8500, 3, 2, 2, 2, 8500, 8509, 5, 1114, 558, 2, 8501, 8510, 5, 1112, 557, 2, 8502, 8507, 7, 37, 2, 2, 8503, 8504, 7, 6, 2, 2, 8504, 8505, 5, 1346, 674, 2, 8505, 8506, 7, 7, 2, 2, 8506, 8508, 3, 2, 2, 2, 8507, 8503, 3, 2, 2, 2, 8507, 8508, 3, 2, 2, 2, 8508, 8510, 3, 2, 2, 2, 8509, 8501, 3, 2, 2, 2, 8509, 8502, 3, 2, 2, 2, 8510, 8516, 3, 2, 2, 2, 8511, 8512, 5, 1326, 664, 2, 8512, 8513, 7, 29, 2, 2, 8513, 8514, 9, 41, 2, 2, 8514, 8516, 3, 2, 2, 2, 8515, 8498, 3, 2, 2, 2, 8515, 8511, 3, 2, 2, 2, 8516, 1111, 3, 2, 2, 2, 8517, 8519, 7, 6, 2, 2, 8518, 8520, 5, 1346, 674, 2, 8519, 8518, 3, 2, 2, 2, 8519, 8520, 3, 2, 2, 2, 8520, 8521, 3, 2, 2, 2, 8521, 8523, 7, 7, 2, 2, 8522, 8517, 3, 2, 2, 2, 8523, 8526, 3, 2, 2, 2, 8524, 8522, 3, 2, 2, 2, 8524, 8525, 3, 2, 2, 2, 8525, 1113, 3, 2, 2, 2, 8526, 8524, 3, 2, 2, 2, 8527, 8541, 5, 1118, 560, 2, 8528, 8541, 5, 1122, 562, 2, 8529, 8541, 5, 1126, 564, 2, 8530, 8541, 5, 1134, 568, 2, 8531, 8541, 5, 1142, 572, 2, 8532, 8538, 5, 1144, 573, 2, 8533, 8539, 5, 1148, 575, 2, 8534, 8535, 7, 4, 2, 2, 8535, 8536, 5, 1346, 674, 2, 8536, 8537, 7, 5, 2, 2, 8537, 8539, 3, 2, 2, 2, 8538, 8533, 3, 2, 2, 2, 8538, 8534, 3, 2, 2, 2, 8539, 8541, 3, 2, 2, 2, 8540, 8527, 3, 2, 2, 2, 8540, 8528, 3, 2, 2, 2, 8540, 8529, 3, 2, 2, 2, 8540, 8530, 3, 2, 2, 2, 8540, 8531, 3, 2, 2, 2, 8540, 8532, 3, 2, 2, 2, 8541, 1115, 3, 2, 2, 2, 8542, 8547, 5, 1122, 562, 2, 8543, 8547, 5, 1128, 565, 2, 8544, 8547, 5, 1136, 569, 2, 8545, 8547, 5, 1142, 572, 2, 8546, 8542, 3, 2, 2, 2, 8546, 8543, 3, 2, 2, 2, 8546, 8544, 3, 2, 2, 2, 8546, 8545, 3, 2, 2, 2, 8547, 1117, 3, 2, 2, 2, 8548, 8550, 5, 1364, 683, 2, 8549, 8551, 5, 528, 265, 2, 8550, 8549, 3, 2, 2, 2, 8550, 8551, 3, 2, 2, 2, 8551, 8552, 3, 2, 2, 2, 8552, 8553, 5, 1120, 561, 2, 8553, 1119, 3, 2, 2, 2, 8554, 8555, 7, 4, 2, 2, 8555, 8556, 5, 1270, 636, 2, 8556, 8557, 7, 5, 2, 2, 8557, 8560, 3, 2, 2, 2, 8558, 8560, 3, 2, 2, 2, 8559, 8554, 3, 2, 2, 2, 8559, 8558, 3, 2, 2, 2, 8560, 1121, 3, 2, 2, 2, 8561, 8578, 7, 394, 2, 2, 8562, 8578, 7, 395, 2, 2, 8563, 8578, 7, 409, 2, 2, 8564, 8578, 7, 381, 2, 2, 8565, 8578, 7, 406, 2, 2, 8566, 8567, 7, 391, 2, 2, 8567, 8578, 5, 1124, 563, 2, 8568, 8569, 7, 192, 2, 2, 8569, 8578, 7, 405, 2, 2, 8570, 8571, 7, 388, 2, 2, 8571, 8578, 5, 1120, 561, 2, 8572, 8573, 7, 387, 2, 2, 8573, 8578, 5, 1120, 561, 2, 8574, 8575, 7, 402, 2, 2, 8575, 8578, 5, 1120, 561, 2, 8576, 8578, 7, 383, 2, 2, 8577, 8561, 3, 2, 2, 2, 8577, 8562, 3, 2, 2, 2, 8577, 8563, 3, 2, 2, 2, 8577, 8564, 3, 2, 2, 2, 8577, 8565, 3, 2, 2, 2, 8577, 8566, 3, 2, 2, 2, 8577, 8568, 3, 2, 2, 2, 8577, 8570, 3, 2, 2, 2, 8577, 8572, 3, 2, 2, 2, 8577, 8574, 3, 2, 2, 2, 8577, 8576, 3, 2, 2, 2, 8578, 1123, 3, 2, 2, 2, 8579, 8580, 7, 4, 2, 2, 8580, 8581, 5, 1346, 674, 2, 8581, 8582, 7, 5, 2, 2, 8582, 8585, 3, 2, 2, 2, 8583, 8585, 3, 2, 2, 2, 8584, 8579, 3, 2, 2, 2, 8584, 8583, 3, 2, 2, 2, 8585, 1125, 3, 2, 2, 2, 8586, 8589, 5, 1130, 566, 2, 8587, 8589, 5, 1132, 567, 2, 8588, 8586, 3, 2, 2, 2, 8588, 8587, 3, 2, 2, 2, 8589, 1127, 3, 2, 2, 2, 8590, 8593, 5, 1130, 566, 2, 8591, 8593, 5, 1132, 567, 2, 8592, 8590, 3, 2, 2, 2, 8592, 8591, 3, 2, 2, 2, 8593, 1129, 3, 2, 2, 2, 8594, 8595, 7, 382, 2, 2, 8595, 8596, 5, 1140, 571, 2, 8596, 8597, 7, 4, 2, 2, 8597, 8598, 5, 1270, 636, 2, 8598, 8599, 7, 5, 2, 2, 8599, 1131, 3, 2, 2, 2, 8600, 8601, 7, 382, 2, 2, 8601, 8602, 5, 1140, 571, 2, 8602, 1133, 3, 2, 2, 2, 8603, 8608, 5, 1138, 570, 2, 8604, 8605, 7, 4, 2, 2, 8605, 8606, 5, 1346, 674, 2, 8606, 8607, 7, 5, 2, 2, 8607, 8609, 3, 2, 2, 2, 8608, 8604, 3, 2, 2, 2, 8608, 8609, 3, 2, 2, 2, 8609, 1135, 3, 2, 2, 2, 8610, 8615, 5, 1138, 570, 2, 8611, 8612, 7, 4, 2, 2, 8612, 8613, 5, 1346, 674, 2, 8613, 8614, 7, 5, 2, 2, 8614, 8616, 3, 2, 2, 2, 8615, 8611, 3, 2, 2, 2, 8615, 8616, 3, 2, 2, 2, 8616, 1137, 3, 2, 2, 2, 8617, 8618, 9, 42, 2, 2, 8618, 8624, 5, 1140, 571, 2, 8619, 8624, 7, 416, 2, 2, 8620, 8621, 7, 398, 2, 2, 8621, 8622, 9, 43, 2, 2, 8622, 8624, 5, 1140, 571, 2, 8623, 8617, 3, 2, 2, 2, 8623, 8619, 3, 2, 2, 2, 8623, 8620, 3, 2, 2, 2, 8624, 1139, 3, 2, 2, 2, 8625, 8628, 7, 367, 2, 2, 8626, 8628, 3, 2, 2, 2, 8627, 8625, 3, 2, 2, 2, 8627, 8626, 3, 2, 2, 2, 8628, 1141, 3, 2, 2, 2, 8629, 8634, 9, 44, 2, 2, 8630, 8631, 7, 4, 2, 2, 8631, 8632, 5, 1346, 674, 2, 8632, 8633, 7, 5, 2, 2, 8633, 8635, 3, 2, 2, 2, 8634, 8630, 3, 2, 2, 2, 8634, 8635, 3, 2, 2, 2, 8635, 8636, 3, 2, 2, 2, 8636, 8637, 5, 1146, 574, 2, 8637, 1143, 3, 2, 2, 2, 8638, 8639, 7, 396, 2, 2, 8639, 1145, 3, 2, 2, 2, 8640, 8641, 7, 107, 2, 2, 8641, 8642, 7, 411, 2, 2, 8642, 8648, 7, 379, 2, 2, 8643, 8644, 7, 372, 2, 2, 8644, 8645, 7, 411, 2, 2, 8645, 8648, 7, 379, 2, 2, 8646, 8648, 3, 2, 2, 2, 8647, 8640, 3, 2, 2, 2, 8647, 8643, 3, 2, 2, 2, 8647, 8646, 3, 2, 2, 2, 8648, 1147, 3, 2, 2, 2, 8649, 8676, 7, 377, 2, 2, 8650, 8676, 7, 257, 2, 2, 8651, 8676, 7, 178, 2, 2, 8652, 8676, 7, 220, 2, 2, 8653, 8676, 7, 254, 2, 2, 8654, 8676, 5, 1150, 576, 2, 8655, 8656, 7, 377, 2, 2, 8656, 8657, 7, 96, 2, 2, 8657, 8676, 7, 257, 2, 2, 8658, 8659, 7, 178, 2, 2, 8659, 8663, 7, 96, 2, 2, 8660, 8664, 7, 220, 2, 2, 8661, 8664, 7, 254, 2, 2, 8662, 8664, 5, 1150, 576, 2, 8663, 8660, 3, 2, 2, 2, 8663, 8661, 3, 2, 2, 2, 8663, 8662, 3, 2, 2, 2, 8664, 8676, 3, 2, 2, 2, 8665, 8666, 7, 220, 2, 2, 8666, 8669, 7, 96, 2, 2, 8667, 8670, 7, 254, 2, 2, 8668, 8670, 5, 1150, 576, 2, 8669, 8667, 3, 2, 2, 2, 8669, 8668, 3, 2, 2, 2, 8670, 8676, 3, 2, 2, 2, 8671, 8672, 7, 254, 2, 2, 8672, 8673, 7, 96, 2, 2, 8673, 8676, 5, 1150, 576, 2, 8674, 8676, 3, 2, 2, 2, 8675, 8649, 3, 2, 2, 2, 8675, 8650, 3, 2, 2, 2, 8675, 8651, 3, 2, 2, 2, 8675, 8652, 3, 2, 2, 2, 8675, 8653, 3, 2, 2, 2, 8675, 8654, 3, 2, 2, 2, 8675, 8655, 3, 2, 2, 2, 8675, 8658, 3, 2, 2, 2, 8675, 8665, 3, 2, 2, 2, 8675, 8671, 3, 2, 2, 2, 8675, 8674, 3, 2, 2, 2, 8676, 1149, 3, 2, 2, 2, 8677, 8682, 7, 319, 2, 2, 8678, 8679, 7, 4, 2, 2, 8679, 8680, 5, 1346, 674, 2, 8680, 8681, 7, 5, 2, 2, 8681, 8683, 3, 2, 2, 2, 8682, 8678, 3, 2, 2, 2, 8682, 8683, 3, 2, 2, 2, 8683, 1151, 3, 2, 2, 2, 8684, 8685, 7, 199, 2, 2, 8685, 8688, 5, 1154, 578, 2, 8686, 8688, 3, 2, 2, 2, 8687, 8684, 3, 2, 2, 2, 8687, 8686, 3, 2, 2, 2, 8688, 1153, 3, 2, 2, 2, 8689, 8690, 5, 1156, 579, 2, 8690, 1155, 3, 2, 2, 2, 8691, 8693, 5, 1158, 580, 2, 8692, 8694, 5, 1264, 633, 2, 8693, 8692, 3, 2, 2, 2, 8693, 8694, 3, 2, 2, 2, 8694, 1157, 3, 2, 2, 2, 8695, 8700, 5, 1160, 581, 2, 8696, 8697, 9, 45, 2, 2, 8697, 8699, 5, 1160, 581, 2, 8698, 8696, 3, 2, 2, 2, 8699, 8702, 3, 2, 2, 2, 8700, 8698, 3, 2, 2, 2, 8700, 8701, 3, 2, 2, 2, 8701, 1159, 3, 2, 2, 2, 8702, 8700, 3, 2, 2, 2, 8703, 8708, 5, 1162, 582, 2, 8704, 8705, 7, 84, 2, 2, 8705, 8707, 5, 1162, 582, 2, 8706, 8704, 3, 2, 2, 2, 8707, 8710, 3, 2, 2, 2, 8708, 8706, 3, 2, 2, 2, 8708, 8709, 3, 2, 2, 2, 8709, 1161, 3, 2, 2, 2, 8710, 8708, 3, 2, 2, 2, 8711, 8716, 5, 1164, 583, 2, 8712, 8713, 7, 35, 2, 2, 8713, 8715, 5, 1164, 583, 2, 8714, 8712, 3, 2, 2, 2, 8715, 8718, 3, 2, 2, 2, 8716, 8714, 3, 2, 2, 2, 8716, 8717, 3, 2, 2, 2, 8717, 1163, 3, 2, 2, 2, 8718, 8716, 3, 2, 2, 2, 8719, 8725, 5, 1166, 584, 2, 8720, 8722, 7, 79, 2, 2, 8721, 8720, 3, 2, 2, 2, 8721, 8722, 3, 2, 2, 2, 8722, 8723, 3, 2, 2, 2, 8723, 8724, 7, 70, 2, 2, 8724, 8726, 5, 1296, 649, 2, 8725, 8721, 3, 2, 2, 2, 8725, 8726, 3, 2, 2, 2, 8726, 1165, 3, 2, 2, 2, 8727, 8729, 7, 79, 2, 2, 8728, 8727, 3, 2, 2, 2, 8728, 8729, 3, 2, 2, 2, 8729, 8730, 3, 2, 2, 2, 8730, 8731, 5, 1168, 585, 2, 8731, 1167, 3, 2, 2, 2, 8732, 8734, 5, 1170, 586, 2, 8733, 8735, 9, 46, 2, 2, 8734, 8733, 3, 2, 2, 2, 8734, 8735, 3, 2, 2, 2, 8735, 1169, 3, 2, 2, 2, 8736, 8760, 5, 1172, 587, 2, 8737, 8739, 7, 118, 2, 2, 8738, 8740, 7, 79, 2, 2, 8739, 8738, 3, 2, 2, 2, 8739, 8740, 3, 2, 2, 2, 8740, 8758, 3, 2, 2, 2, 8741, 8759, 7, 80, 2, 2, 8742, 8759, 7, 98, 2, 2, 8743, 8759, 7, 62, 2, 2, 8744, 8759, 7, 358, 2, 2, 8745, 8746, 7, 58, 2, 2, 8746, 8747, 7, 66, 2, 2, 8747, 8759, 5, 1154, 578, 2, 8748, 8749, 7, 268, 2, 2, 8749, 8750, 7, 4, 2, 2, 8750, 8751, 5, 1276, 639, 2, 8751, 8752, 7, 5, 2, 2, 8752, 8759, 3, 2, 2, 2, 8753, 8759, 7, 190, 2, 2, 8754, 8756, 5, 1286, 644, 2, 8755, 8754, 3, 2, 2, 2, 8755, 8756, 3, 2, 2, 2, 8756, 8757, 3, 2, 2, 2, 8757, 8759, 7, 471, 2, 2, 8758, 8741, 3, 2, 2, 2, 8758, 8742, 3, 2, 2, 2, 8758, 8743, 3, 2, 2, 2, 8758, 8744, 3, 2, 2, 2, 8758, 8745, 3, 2, 2, 2, 8758, 8748, 3, 2, 2, 2, 8758, 8753, 3, 2, 2, 2, 8758, 8755, 3, 2, 2, 2, 8759, 8761, 3, 2, 2, 2, 8760, 8737, 3, 2, 2, 2, 8760, 8761, 3, 2, 2, 2, 8761, 1171, 3, 2, 2, 2, 8762, 8774, 5, 1174, 588, 2, 8763, 8764, 9, 47, 2, 2, 8764, 8775, 5, 1174, 588, 2, 8765, 8766, 5, 1268, 635, 2, 8766, 8772, 5, 1258, 630, 2, 8767, 8773, 5, 956, 479, 2, 8768, 8769, 7, 4, 2, 2, 8769, 8770, 5, 1154, 578, 2, 8770, 8771, 7, 5, 2, 2, 8771, 8773, 3, 2, 2, 2, 8772, 8767, 3, 2, 2, 2, 8772, 8768, 3, 2, 2, 2, 8773, 8775, 3, 2, 2, 2, 8774, 8763, 3, 2, 2, 2, 8774, 8765, 3, 2, 2, 2, 8774, 8775, 3, 2, 2, 2, 8775, 1173, 3, 2, 2, 2, 8776, 8793, 5, 1176, 589, 2, 8777, 8779, 7, 79, 2, 2, 8778, 8777, 3, 2, 2, 2, 8778, 8779, 3, 2, 2, 2, 8779, 8788, 3, 2, 2, 2, 8780, 8789, 7, 122, 2, 2, 8781, 8789, 7, 116, 2, 2, 8782, 8783, 7, 129, 2, 2, 8783, 8789, 7, 96, 2, 2, 8784, 8786, 7, 380, 2, 2, 8785, 8787, 7, 93, 2, 2, 8786, 8785, 3, 2, 2, 2, 8786, 8787, 3, 2, 2, 2, 8787, 8789, 3, 2, 2, 2, 8788, 8780, 3, 2, 2, 2, 8788, 8781, 3, 2, 2, 2, 8788, 8782, 3, 2, 2, 2, 8788, 8784, 3, 2, 2, 2, 8789, 8790, 3, 2, 2, 2, 8790, 8791, 5, 1176, 589, 2, 8791, 8792, 5, 1152, 577, 2, 8792, 8794, 3, 2, 2, 2, 8793, 8778, 3, 2, 2, 2, 8793, 8794, 3, 2, 2, 2, 8794, 1175, 3, 2, 2, 2, 8795, 8801, 5, 1178, 590, 2, 8796, 8797, 5, 1264, 633, 2, 8797, 8798, 5, 1178, 590, 2, 8798, 8800, 3, 2, 2, 2, 8799, 8796, 3, 2, 2, 2, 8800, 8803, 3, 2, 2, 2, 8801, 8799, 3, 2, 2, 2, 8801, 8802, 3, 2, 2, 2, 8802, 1177, 3, 2, 2, 2, 8803, 8801, 3, 2, 2, 2, 8804, 8806, 5, 1264, 633, 2, 8805, 8804, 3, 2, 2, 2, 8805, 8806, 3, 2, 2, 2, 8806, 8807, 3, 2, 2, 2, 8807, 8808, 5, 1180, 591, 2, 8808, 1179, 3, 2, 2, 2, 8809, 8814, 5, 1182, 592, 2, 8810, 8811, 9, 48, 2, 2, 8811, 8813, 5, 1182, 592, 2, 8812, 8810, 3, 2, 2, 2, 8813, 8816, 3, 2, 2, 2, 8814, 8812, 3, 2, 2, 2, 8814, 8815, 3, 2, 2, 2, 8815, 1181, 3, 2, 2, 2, 8816, 8814, 3, 2, 2, 2, 8817, 8822, 5, 1184, 593, 2, 8818, 8819, 9, 49, 2, 2, 8819, 8821, 5, 1184, 593, 2, 8820, 8818, 3, 2, 2, 2, 8821, 8824, 3, 2, 2, 2, 8822, 8820, 3, 2, 2, 2, 8822, 8823, 3, 2, 2, 2, 8823, 1183, 3, 2, 2, 2, 8824, 8822, 3, 2, 2, 2, 8825, 8828, 5, 1186, 594, 2, 8826, 8827, 7, 17, 2, 2, 8827, 8829, 5, 1154, 578, 2, 8828, 8826, 3, 2, 2, 2, 8828, 8829, 3, 2, 2, 2, 8829, 1185, 3, 2, 2, 2, 8830, 8832, 9, 48, 2, 2, 8831, 8830, 3, 2, 2, 2, 8831, 8832, 3, 2, 2, 2, 8832, 8833, 3, 2, 2, 2, 8833, 8834, 5, 1188, 595, 2, 8834, 1187, 3, 2, 2, 2, 8835, 8840, 5, 1190, 596, 2, 8836, 8837, 7, 144, 2, 2, 8837, 8838, 7, 411, 2, 2, 8838, 8839, 7, 379, 2, 2, 8839, 8841, 5, 1154, 578, 2, 8840, 8836, 3, 2, 2, 2, 8840, 8841, 3, 2, 2, 2, 8841, 1189, 3, 2, 2, 2, 8842, 8845, 5, 1192, 597, 2, 8843, 8844, 7, 45, 2, 2, 8844, 8846, 5, 526, 264, 2, 8845, 8843, 3, 2, 2, 2, 8845, 8846, 3, 2, 2, 2, 8846, 1191, 3, 2, 2, 2, 8847, 8852, 5, 1196, 599, 2, 8848, 8849, 7, 28, 2, 2, 8849, 8851, 5, 1110, 556, 2, 8850, 8848, 3, 2, 2, 2, 8851, 8854, 3, 2, 2, 2, 8852, 8850, 3, 2, 2, 2, 8852, 8853, 3, 2, 2, 2, 8853, 1193, 3, 2, 2, 2, 8854, 8852, 3, 2, 2, 2, 8855, 8856, 8, 598, 1, 2, 8856, 8863, 5, 1196, 599, 2, 8857, 8858, 9, 48, 2, 2, 8858, 8863, 5, 1194, 598, 11, 8859, 8860, 5, 1264, 633, 2, 8860, 8861, 5, 1194, 598, 5, 8861, 8863, 3, 2, 2, 2, 8862, 8855, 3, 2, 2, 2, 8862, 8857, 3, 2, 2, 2, 8862, 8859, 3, 2, 2, 2, 8863, 8903, 3, 2, 2, 2, 8864, 8865, 12, 10, 2, 2, 8865, 8866, 7, 17, 2, 2, 8866, 8902, 5, 1194, 598, 11, 8867, 8868, 12, 9, 2, 2, 8868, 8869, 9, 49, 2, 2, 8869, 8902, 5, 1194, 598, 10, 8870, 8871, 12, 8, 2, 2, 8871, 8872, 9, 48, 2, 2, 8872, 8902, 5, 1194, 598, 9, 8873, 8874, 12, 7, 2, 2, 8874, 8875, 5, 1264, 633, 2, 8875, 8876, 5, 1194, 598, 8, 8876, 8902, 3, 2, 2, 2, 8877, 8878, 12, 6, 2, 2, 8878, 8879, 9, 47, 2, 2, 8879, 8902, 5, 1194, 598, 7, 8880, 8881, 12, 12, 2, 2, 8881, 8882, 7, 28, 2, 2, 8882, 8902, 5, 1110, 556, 2, 8883, 8884, 12, 4, 2, 2, 8884, 8902, 5, 1264, 633, 2, 8885, 8886, 12, 3, 2, 2, 8886, 8888, 7, 118, 2, 2, 8887, 8889, 7, 79, 2, 2, 8888, 8887, 3, 2, 2, 2, 8888, 8889, 3, 2, 2, 2, 8889, 8899, 3, 2, 2, 2, 8890, 8891, 7, 58, 2, 2, 8891, 8892, 7, 66, 2, 2, 8892, 8900, 5, 1194, 598, 2, 8893, 8894, 7, 268, 2, 2, 8894, 8895, 7, 4, 2, 2, 8895, 8896, 5, 1276, 639, 2, 8896, 8897, 7, 5, 2, 2, 8897, 8900, 3, 2, 2, 2, 8898, 8900, 7, 190, 2, 2, 8899, 8890, 3, 2, 2, 2, 8899, 8893, 3, 2, 2, 2, 8899, 8898, 3, 2, 2, 2, 8900, 8902, 3, 2, 2, 2, 8901, 8864, 3, 2, 2, 2, 8901, 8867, 3, 2, 2, 2, 8901, 8870, 3, 2, 2, 2, 8901, 8873, 3, 2, 2, 2, 8901, 8877, 3, 2, 2, 2, 8901, 8880, 3, 2, 2, 2, 8901, 8883, 3, 2, 2, 2, 8901, 8885, 3, 2, 2, 2, 8902, 8905, 3, 2, 2, 2, 8903, 8901, 3, 2, 2, 2, 8903, 8904, 3, 2, 2, 2, 8904, 1195, 3, 2, 2, 2, 8905, 8903, 3, 2, 2, 2, 8906, 8907, 7, 389, 2, 2, 8907, 8943, 5, 956, 479, 2, 8908, 8911, 7, 37, 2, 2, 8909, 8912, 5, 956, 479, 2, 8910, 8912, 5, 1278, 640, 2, 8911, 8909, 3, 2, 2, 2, 8911, 8910, 3, 2, 2, 2, 8912, 8943, 3, 2, 2, 2, 8913, 8914, 7, 30, 2, 2, 8914, 8943, 5, 1316, 659, 2, 8915, 8916, 7, 463, 2, 2, 8916, 8917, 7, 4, 2, 2, 8917, 8918, 5, 1270, 636, 2, 8918, 8919, 7, 5, 2, 2, 8919, 8943, 3, 2, 2, 2, 8920, 8921, 7, 100, 2, 2, 8921, 8943, 5, 956, 479, 2, 8922, 8943, 5, 1308, 655, 2, 8923, 8943, 5, 1338, 670, 2, 8924, 8943, 5, 1198, 600, 2, 8925, 8926, 7, 4, 2, 2, 8926, 8927, 5, 1154, 578, 2, 8927, 8928, 7, 5, 2, 2, 8928, 8929, 5, 1316, 659, 2, 8929, 8943, 3, 2, 2, 2, 8930, 8943, 5, 1298, 650, 2, 8931, 8943, 5, 1202, 602, 2, 8932, 8934, 5, 956, 479, 2, 8933, 8935, 5, 1314, 658, 2, 8934, 8933, 3, 2, 2, 2, 8934, 8935, 3, 2, 2, 2, 8935, 8943, 3, 2, 2, 2, 8936, 8943, 5, 1254, 628, 2, 8937, 8943, 5, 1256, 629, 2, 8938, 8939, 5, 1252, 627, 2, 8939, 8940, 7, 127, 2, 2, 8940, 8941, 5, 1252, 627, 2, 8941, 8943, 3, 2, 2, 2, 8942, 8906, 3, 2, 2, 2, 8942, 8908, 3, 2, 2, 2, 8942, 8913, 3, 2, 2, 2, 8942, 8915, 3, 2, 2, 2, 8942, 8920, 3, 2, 2, 2, 8942, 8922, 3, 2, 2, 2, 8942, 8923, 3, 2, 2, 2, 8942, 8924, 3, 2, 2, 2, 8942, 8925, 3, 2, 2, 2, 8942, 8930, 3, 2, 2, 2, 8942, 8931, 3, 2, 2, 2, 8942, 8932, 3, 2, 2, 2, 8942, 8936, 3, 2, 2, 2, 8942, 8937, 3, 2, 2, 2, 8942, 8938, 3, 2, 2, 2, 8943, 1197, 3, 2, 2, 2, 8944, 8945, 7, 539, 2, 2, 8945, 1199, 3, 2, 2, 2, 8946, 8947, 5, 1336, 669, 2, 8947, 8966, 7, 4, 2, 2, 8948, 8952, 5, 1272, 637, 2, 8949, 8950, 7, 8, 2, 2, 8950, 8951, 7, 103, 2, 2, 8951, 8953, 5, 1274, 638, 2, 8952, 8949, 3, 2, 2, 2, 8952, 8953, 3, 2, 2, 2, 8953, 8954, 3, 2, 2, 2, 8954, 8955, 5, 992, 497, 2, 8955, 8967, 3, 2, 2, 2, 8956, 8957, 7, 103, 2, 2, 8957, 8958, 5, 1274, 638, 2, 8958, 8959, 5, 992, 497, 2, 8959, 8967, 3, 2, 2, 2, 8960, 8961, 9, 50, 2, 2, 8961, 8962, 5, 1272, 637, 2, 8962, 8963, 5, 992, 497, 2, 8963, 8967, 3, 2, 2, 2, 8964, 8967, 7, 11, 2, 2, 8965, 8967, 3, 2, 2, 2, 8966, 8948, 3, 2, 2, 2, 8966, 8956, 3, 2, 2, 2, 8966, 8960, 3, 2, 2, 2, 8966, 8964, 3, 2, 2, 2, 8966, 8965, 3, 2, 2, 2, 8967, 8968, 3, 2, 2, 2, 8968, 8969, 7, 5, 2, 2, 8969, 1201, 3, 2, 2, 2, 8970, 8971, 5, 1200, 601, 2, 8971, 8972, 5, 1226, 614, 2, 8972, 8973, 5, 1228, 615, 2, 8973, 8974, 5, 1236, 619, 2, 8974, 8977, 3, 2, 2, 2, 8975, 8977, 5, 1206, 604, 2, 8976, 8970, 3, 2, 2, 2, 8976, 8975, 3, 2, 2, 2, 8977, 1203, 3, 2, 2, 2, 8978, 8981, 5, 1200, 601, 2, 8979, 8981, 5, 1206, 604, 2, 8980, 8978, 3, 2, 2, 2, 8980, 8979, 3, 2, 2, 2, 8981, 1205, 3, 2, 2, 2, 8982, 8983, 7, 110, 2, 2, 8983, 8984, 7, 64, 2, 2, 8984, 8985, 7, 4, 2, 2, 8985, 8986, 5, 1154, 578, 2, 8986, 8987, 7, 5, 2, 2, 8987, 9160, 3, 2, 2, 2, 8988, 9160, 7, 50, 2, 2, 8989, 8994, 7, 52, 2, 2, 8990, 8991, 7, 4, 2, 2, 8991, 8992, 5, 1346, 674, 2, 8992, 8993, 7, 5, 2, 2, 8993, 8995, 3, 2, 2, 2, 8994, 8990, 3, 2, 2, 2, 8994, 8995, 3, 2, 2, 2, 8995, 9160, 3, 2, 2, 2, 8996, 9001, 7, 53, 2, 2, 8997, 8998, 7, 4, 2, 2, 8998, 8999, 5, 1346, 674, 2, 8999, 9000, 7, 5, 2, 2, 9000, 9002, 3, 2, 2, 2, 9001, 8997, 3, 2, 2, 2, 9001, 9002, 3, 2, 2, 2, 9002, 9160, 3, 2, 2, 2, 9003, 9008, 7, 77, 2, 2, 9004, 9005, 7, 4, 2, 2, 9005, 9006, 5, 1346, 674, 2, 9006, 9007, 7, 5, 2, 2, 9007, 9009, 3, 2, 2, 2, 9008, 9004, 3, 2, 2, 2, 9008, 9009, 3, 2, 2, 2, 9009, 9160, 3, 2, 2, 2, 9010, 9015, 7, 78, 2, 2, 9011, 9012, 7, 4, 2, 2, 9012, 9013, 5, 1346, 674, 2, 9013, 9014, 7, 5, 2, 2, 9014, 9016, 3, 2, 2, 2, 9015, 9011, 3, 2, 2, 2, 9015, 9016, 3, 2, 2, 2, 9016, 9160, 3, 2, 2, 2, 9017, 9160, 7, 51, 2, 2, 9018, 9160, 7, 54, 2, 2, 9019, 9160, 7, 91, 2, 2, 9020, 9160, 7, 101, 2, 2, 9021, 9160, 7, 49, 2, 2, 9022, 9160, 7, 113, 2, 2, 9023, 9024, 7, 43, 2, 2, 9024, 9025, 7, 4, 2, 2, 9025, 9026, 5, 1154, 578, 2, 9026, 9027, 7, 38, 2, 2, 9027, 9028, 5, 1110, 556, 2, 9028, 9029, 7, 5, 2, 2, 9029, 9160, 3, 2, 2, 2, 9030, 9031, 7, 390, 2, 2, 9031, 9032, 7, 4, 2, 2, 9032, 9033, 5, 1282, 642, 2, 9033, 9034, 7, 5, 2, 2, 9034, 9160, 3, 2, 2, 2, 9035, 9036, 7, 482, 2, 2, 9036, 9037, 7, 4, 2, 2, 9037, 9040, 5, 1154, 578, 2, 9038, 9039, 7, 8, 2, 2, 9039, 9041, 5, 1286, 644, 2, 9040, 9038, 3, 2, 2, 2, 9040, 9041, 3, 2, 2, 2, 9041, 9042, 3, 2, 2, 2, 9042, 9043, 7, 5, 2, 2, 9043, 9160, 3, 2, 2, 2, 9044, 9045, 7, 403, 2, 2, 9045, 9046, 7, 4, 2, 2, 9046, 9047, 5, 1288, 645, 2, 9047, 9048, 7, 5, 2, 2, 9048, 9160, 3, 2, 2, 2, 9049, 9050, 7, 404, 2, 2, 9050, 9051, 7, 4, 2, 2, 9051, 9052, 5, 1290, 646, 2, 9052, 9053, 7, 5, 2, 2, 9053, 9160, 3, 2, 2, 2, 9054, 9055, 7, 410, 2, 2, 9055, 9056, 7, 4, 2, 2, 9056, 9057, 5, 1292, 647, 2, 9057, 9058, 7, 5, 2, 2, 9058, 9160, 3, 2, 2, 2, 9059, 9060, 7, 413, 2, 2, 9060, 9061, 7, 4, 2, 2, 9061, 9062, 5, 1154, 578, 2, 9062, 9063, 7, 38, 2, 2, 9063, 9064, 5, 1110, 556, 2, 9064, 9065, 7, 5, 2, 2, 9065, 9160, 3, 2, 2, 2, 9066, 9067, 7, 414, 2, 2, 9067, 9069, 7, 4, 2, 2, 9068, 9070, 9, 51, 2, 2, 9069, 9068, 3, 2, 2, 2, 9069, 9070, 3, 2, 2, 2, 9070, 9071, 3, 2, 2, 2, 9071, 9072, 5, 1294, 648, 2, 9072, 9073, 7, 5, 2, 2, 9073, 9160, 3, 2, 2, 2, 9074, 9075, 7, 401, 2, 2, 9075, 9076, 7, 4, 2, 2, 9076, 9077, 5, 1154, 578, 2, 9077, 9078, 7, 8, 2, 2, 9078, 9079, 5, 1154, 578, 2, 9079, 9080, 7, 5, 2, 2, 9080, 9160, 3, 2, 2, 2, 9081, 9082, 7, 386, 2, 2, 9082, 9083, 7, 4, 2, 2, 9083, 9084, 5, 1270, 636, 2, 9084, 9085, 7, 5, 2, 2, 9085, 9160, 3, 2, 2, 2, 9086, 9087, 7, 392, 2, 2, 9087, 9088, 7, 4, 2, 2, 9088, 9089, 5, 1270, 636, 2, 9089, 9090, 7, 5, 2, 2, 9090, 9160, 3, 2, 2, 2, 9091, 9092, 7, 397, 2, 2, 9092, 9093, 7, 4, 2, 2, 9093, 9094, 5, 1270, 636, 2, 9094, 9095, 7, 5, 2, 2, 9095, 9160, 3, 2, 2, 2, 9096, 9097, 7, 418, 2, 2, 9097, 9098, 7, 4, 2, 2, 9098, 9099, 5, 1270, 636, 2, 9099, 9100, 7, 5, 2, 2, 9100, 9160, 3, 2, 2, 2, 9101, 9102, 7, 419, 2, 2, 9102, 9103, 7, 4, 2, 2, 9103, 9104, 7, 259, 2, 2, 9104, 9110, 5, 1368, 685, 2, 9105, 9108, 7, 8, 2, 2, 9106, 9109, 5, 1212, 607, 2, 9107, 9109, 5, 1270, 636, 2, 9108, 9106, 3, 2, 2, 2, 9108, 9107, 3, 2, 2, 2, 9109, 9111, 3, 2, 2, 2, 9110, 9105, 3, 2, 2, 2, 9110, 9111, 3, 2, 2, 2, 9111, 9112, 3, 2, 2, 2, 9112, 9113, 7, 5, 2, 2, 9113, 9160, 3, 2, 2, 2, 9114, 9115, 7, 420, 2, 2, 9115, 9116, 7, 4, 2, 2, 9116, 9117, 5, 1196, 599, 2, 9117, 9118, 5, 1222, 612, 2, 9118, 9119, 7, 5, 2, 2, 9119, 9160, 3, 2, 2, 2, 9120, 9121, 7, 421, 2, 2, 9121, 9122, 7, 4, 2, 2, 9122, 9123, 5, 1214, 608, 2, 9123, 9124, 7, 5, 2, 2, 9124, 9160, 3, 2, 2, 2, 9125, 9126, 7, 422, 2, 2, 9126, 9127, 7, 4, 2, 2, 9127, 9128, 5, 1218, 610, 2, 9128, 9129, 5, 1154, 578, 2, 9129, 9130, 5, 1220, 611, 2, 9130, 9131, 7, 5, 2, 2, 9131, 9160, 3, 2, 2, 2, 9132, 9133, 7, 423, 2, 2, 9133, 9134, 7, 4, 2, 2, 9134, 9135, 7, 259, 2, 2, 9135, 9138, 5, 1368, 685, 2, 9136, 9137, 7, 8, 2, 2, 9137, 9139, 5, 1154, 578, 2, 9138, 9136, 3, 2, 2, 2, 9138, 9139, 3, 2, 2, 2, 9139, 9140, 3, 2, 2, 2, 9140, 9141, 7, 5, 2, 2, 9141, 9160, 3, 2, 2, 2, 9142, 9143, 7, 424, 2, 2, 9143, 9144, 7, 4, 2, 2, 9144, 9145, 7, 376, 2, 2, 9145, 9146, 5, 1154, 578, 2, 9146, 9147, 7, 8, 2, 2, 9147, 9148, 5, 1208, 605, 2, 9148, 9149, 5, 1210, 606, 2, 9149, 9150, 7, 5, 2, 2, 9150, 9160, 3, 2, 2, 2, 9151, 9152, 7, 425, 2, 2, 9152, 9153, 7, 4, 2, 2, 9153, 9154, 5, 1218, 610, 2, 9154, 9155, 5, 1154, 578, 2, 9155, 9156, 7, 38, 2, 2, 9156, 9157, 5, 1114, 558, 2, 9157, 9158, 7, 5, 2, 2, 9158, 9160, 3, 2, 2, 2, 9159, 8982, 3, 2, 2, 2, 9159, 8988, 3, 2, 2, 2, 9159, 8989, 3, 2, 2, 2, 9159, 8996, 3, 2, 2, 2, 9159, 9003, 3, 2, 2, 2, 9159, 9010, 3, 2, 2, 2, 9159, 9017, 3, 2, 2, 2, 9159, 9018, 3, 2, 2, 2, 9159, 9019, 3, 2, 2, 2, 9159, 9020, 3, 2, 2, 2, 9159, 9021, 3, 2, 2, 2, 9159, 9022, 3, 2, 2, 2, 9159, 9023, 3, 2, 2, 2, 9159, 9030, 3, 2, 2, 2, 9159, 9035, 3, 2, 2, 2, 9159, 9044, 3, 2, 2, 2, 9159, 9049, 3, 2, 2, 2, 9159, 9054, 3, 2, 2, 2, 9159, 9059, 3, 2, 2, 2, 9159, 9066, 3, 2, 2, 2, 9159, 9074, 3, 2, 2, 2, 9159, 9081, 3, 2, 2, 2, 9159, 9086, 3, 2, 2, 2, 9159, 9091, 3, 2, 2, 2, 9159, 9096, 3, 2, 2, 2, 9159, 9101, 3, 2, 2, 2, 9159, 9114, 3, 2, 2, 2, 9159, 9120, 3, 2, 2, 2, 9159, 9125, 3, 2, 2, 2, 9159, 9132, 3, 2, 2, 2, 9159, 9142, 3, 2, 2, 2, 9159, 9151, 3, 2, 2, 2, 9160, 1207, 3, 2, 2, 2, 9161, 9162, 7, 368, 2, 2, 9162, 9167, 5, 1154, 578, 2, 9163, 9164, 7, 368, 2, 2, 9164, 9165, 7, 262, 2, 2, 9165, 9167, 7, 443, 2, 2, 9166, 9161, 3, 2, 2, 2, 9166, 9163, 3, 2, 2, 2, 9167, 1209, 3, 2, 2, 2, 9168, 9169, 7, 8, 2, 2, 9169, 9170, 7, 332, 2, 2, 9170, 9180, 7, 378, 2, 2, 9171, 9172, 7, 8, 2, 2, 9172, 9173, 7, 332, 2, 2, 9173, 9180, 7, 262, 2, 2, 9174, 9175, 7, 8, 2, 2, 9175, 9176, 7, 332, 2, 2, 9176, 9177, 7, 262, 2, 2, 9177, 9180, 7, 443, 2, 2, 9178, 9180, 3, 2, 2, 2, 9179, 9168, 3, 2, 2, 2, 9179, 9171, 3, 2, 2, 2, 9179, 9174, 3, 2, 2, 2, 9179, 9178, 3, 2, 2, 2, 9180, 1211, 3, 2, 2, 2, 9181, 9182, 7, 417, 2, 2, 9182, 9183, 7, 4, 2, 2, 9183, 9184, 5, 1214, 608, 2, 9184, 9185, 7, 5, 2, 2, 9185, 1213, 3, 2, 2, 2, 9186, 9191, 5, 1216, 609, 2, 9187, 9188, 7, 8, 2, 2, 9188, 9190, 5, 1216, 609, 2, 9189, 9187, 3, 2, 2, 2, 9190, 9193, 3, 2, 2, 2, 9191, 9189, 3, 2, 2, 2, 9191, 9192, 3, 2, 2, 2, 9192, 1215, 3, 2, 2, 2, 9193, 9191, 3, 2, 2, 2, 9194, 9197, 5, 1154, 578, 2, 9195, 9196, 7, 38, 2, 2, 9196, 9198, 5, 1368, 685, 2, 9197, 9195, 3, 2, 2, 2, 9197, 9198, 3, 2, 2, 2, 9198, 1217, 3, 2, 2, 2, 9199, 9200, 9, 52, 2, 2, 9200, 1219, 3, 2, 2, 2, 9201, 9202, 7, 285, 2, 2, 9202, 9207, 7, 371, 2, 2, 9203, 9204, 7, 340, 2, 2, 9204, 9207, 7, 371, 2, 2, 9205, 9207, 3, 2, 2, 2, 9206, 9201, 3, 2, 2, 2, 9206, 9203, 3, 2, 2, 2, 9206, 9205, 3, 2, 2, 2, 9207, 1221, 3, 2, 2, 2, 9208, 9209, 7, 279, 2, 2, 9209, 9224, 5, 1196, 599, 2, 9210, 9211, 7, 279, 2, 2, 9211, 9212, 5, 1196, 599, 2, 9212, 9213, 5, 1224, 613, 2, 9213, 9224, 3, 2, 2, 2, 9214, 9215, 7, 279, 2, 2, 9215, 9216, 5, 1224, 613, 2, 9216, 9217, 5, 1196, 599, 2, 9217, 9224, 3, 2, 2, 2, 9218, 9219, 7, 279, 2, 2, 9219, 9220, 5, 1224, 613, 2, 9220, 9221, 5, 1196, 599, 2, 9221, 9222, 5, 1224, 613, 2, 9222, 9224, 3, 2, 2, 2, 9223, 9208, 3, 2, 2, 2, 9223, 9210, 3, 2, 2, 2, 9223, 9214, 3, 2, 2, 2, 9223, 9218, 3, 2, 2, 2, 9224, 1223, 3, 2, 2, 2, 9225, 9226, 7, 149, 2, 2, 9226, 9227, 9, 53, 2, 2, 9227, 1225, 3, 2, 2, 2, 9228, 9229, 7, 472, 2, 2, 9229, 9230, 7, 68, 2, 2, 9230, 9231, 7, 4, 2, 2, 9231, 9232, 5, 994, 498, 2, 9232, 9233, 7, 5, 2, 2, 9233, 9236, 3, 2, 2, 2, 9234, 9236, 3, 2, 2, 2, 9235, 9228, 3, 2, 2, 2, 9235, 9234, 3, 2, 2, 2, 9236, 1227, 3, 2, 2, 2, 9237, 9238, 7, 473, 2, 2, 9238, 9239, 7, 4, 2, 2, 9239, 9240, 7, 105, 2, 2, 9240, 9241, 5, 1154, 578, 2, 9241, 9242, 7, 5, 2, 2, 9242, 9245, 3, 2, 2, 2, 9243, 9245, 3, 2, 2, 2, 9244, 9237, 3, 2, 2, 2, 9244, 9243, 3, 2, 2, 2, 9245, 1229, 3, 2, 2, 2, 9246, 9247, 7, 106, 2, 2, 9247, 9250, 5, 1232, 617, 2, 9248, 9250, 3, 2, 2, 2, 9249, 9246, 3, 2, 2, 2, 9249, 9248, 3, 2, 2, 2, 9250, 1231, 3, 2, 2, 2, 9251, 9256, 5, 1234, 618, 2, 9252, 9253, 7, 8, 2, 2, 9253, 9255, 5, 1234, 618, 2, 9254, 9252, 3, 2, 2, 2, 9255, 9258, 3, 2, 2, 2, 9256, 9254, 3, 2, 2, 2, 9256, 9257, 3, 2, 2, 2, 9257, 1233, 3, 2, 2, 2, 9258, 9256, 3, 2, 2, 2, 9259, 9260, 5, 1362, 682, 2, 9260, 9261, 7, 38, 2, 2, 9261, 9262, 5, 1238, 620, 2, 9262, 1235, 3, 2, 2, 2, 9263, 9266, 7, 126, 2, 2, 9264, 9267, 5, 1238, 620, 2, 9265, 9267, 5, 1362, 682, 2, 9266, 9264, 3, 2, 2, 2, 9266, 9265, 3, 2, 2, 2, 9267, 9270, 3, 2, 2, 2, 9268, 9270, 3, 2, 2, 2, 9269, 9263, 3, 2, 2, 2, 9269, 9268, 3, 2, 2, 2, 9270, 1237, 3, 2, 2, 2, 9271, 9272, 7, 4, 2, 2, 9272, 9273, 5, 1240, 621, 2, 9273, 9274, 5, 1242, 622, 2, 9274, 9275, 5, 992, 497, 2, 9275, 9276, 5, 1244, 623, 2, 9276, 9277, 7, 5, 2, 2, 9277, 1239, 3, 2, 2, 2, 9278, 9281, 5, 1362, 682, 2, 9279, 9281, 3, 2, 2, 2, 9280, 9278, 3, 2, 2, 2, 9280, 9279, 3, 2, 2, 2, 9281, 1241, 3, 2, 2, 2, 9282, 9283, 7, 278, 2, 2, 9283, 9284, 7, 149, 2, 2, 9284, 9287, 5, 1270, 636, 2, 9285, 9287, 3, 2, 2, 2, 9286, 9282, 3, 2, 2, 2, 9286, 9285, 3, 2, 2, 2, 9287, 1243, 3, 2, 2, 2, 9288, 9289, 7, 292, 2, 2, 9289, 9290, 5, 1246, 624, 2, 9290, 9291, 5, 1250, 626, 2, 9291, 9302, 3, 2, 2, 2, 9292, 9293, 7, 313, 2, 2, 9293, 9294, 5, 1246, 624, 2, 9294, 9295, 5, 1250, 626, 2, 9295, 9302, 3, 2, 2, 2, 9296, 9297, 7, 474, 2, 2, 9297, 9298, 5, 1246, 624, 2, 9298, 9299, 5, 1250, 626, 2, 9299, 9302, 3, 2, 2, 2, 9300, 9302, 3, 2, 2, 2, 9301, 9288, 3, 2, 2, 2, 9301, 9292, 3, 2, 2, 2, 9301, 9296, 3, 2, 2, 2, 9301, 9300, 3, 2, 2, 2, 9302, 1245, 3, 2, 2, 2, 9303, 9310, 5, 1248, 625, 2, 9304, 9305, 7, 380, 2, 2, 9305, 9306, 5, 1248, 625, 2, 9306, 9307, 7, 35, 2, 2, 9307, 9308, 5, 1248, 625, 2, 9308, 9310, 3, 2, 2, 2, 9309, 9303, 3, 2, 2, 2, 9309, 9304, 3, 2, 2, 2, 9310, 1247, 3, 2, 2, 2, 9311, 9312, 7, 355, 2, 2, 9312, 9319, 9, 54, 2, 2, 9313, 9314, 7, 427, 2, 2, 9314, 9319, 7, 407, 2, 2, 9315, 9316, 5, 1154, 578, 2, 9316, 9317, 9, 54, 2, 2, 9317, 9319, 3, 2, 2, 2, 9318, 9311, 3, 2, 2, 2, 9318, 9313, 3, 2, 2, 2, 9318, 9315, 3, 2, 2, 2, 9319, 1249, 3, 2, 2, 2, 9320, 9327, 7, 201, 2, 2, 9321, 9322, 7, 427, 2, 2, 9322, 9328, 7, 407, 2, 2, 9323, 9328, 7, 68, 2, 2, 9324, 9328, 7, 460, 2, 2, 9325, 9326, 7, 262, 2, 2, 9326, 9328, 7, 475, 2, 2, 9327, 9321, 3, 2, 2, 2, 9327, 9323, 3, 2, 2, 2, 9327, 9324, 3, 2, 2, 2, 9327, 9325, 3, 2, 2, 2, 9328, 9331, 3, 2, 2, 2, 9329, 9331, 3, 2, 2, 2, 9330, 9320, 3, 2, 2, 2, 9330, 9329, 3, 2, 2, 2, 9331, 1251, 3, 2, 2, 2, 9332, 9333, 7, 407, 2, 2, 9333, 9335, 7, 4, 2, 2, 9334, 9336, 5, 1270, 636, 2, 9335, 9334, 3, 2, 2, 2, 9335, 9336, 3, 2, 2, 2, 9336, 9337, 3, 2, 2, 2, 9337, 9345, 7, 5, 2, 2, 9338, 9339, 7, 4, 2, 2, 9339, 9340, 5, 1270, 636, 2, 9340, 9341, 7, 8, 2, 2, 9341, 9342, 5, 1154, 578, 2, 9342, 9343, 7, 5, 2, 2, 9343, 9345, 3, 2, 2, 2, 9344, 9332, 3, 2, 2, 2, 9344, 9338, 3, 2, 2, 2, 9345, 1253, 3, 2, 2, 2, 9346, 9347, 7, 407, 2, 2, 9347, 9349, 7, 4, 2, 2, 9348, 9350, 5, 1270, 636, 2, 9349, 9348, 3, 2, 2, 2, 9349, 9350, 3, 2, 2, 2, 9350, 9351, 3, 2, 2, 2, 9351, 9352, 7, 5, 2, 2, 9352, 1255, 3, 2, 2, 2, 9353, 9354, 7, 4, 2, 2, 9354, 9355, 5, 1270, 636, 2, 9355, 9356, 7, 8, 2, 2, 9356, 9357, 5, 1154, 578, 2, 9357, 9358, 7, 5, 2, 2, 9358, 1257, 3, 2, 2, 2, 9359, 9360, 9, 55, 2, 2, 9360, 1259, 3, 2, 2, 2, 9361, 9364, 7, 31, 2, 2, 9362, 9364, 5, 1262, 632, 2, 9363, 9361, 3, 2, 2, 2, 9363, 9362, 3, 2, 2, 2, 9364, 1261, 3, 2, 2, 2, 9365, 9366, 9, 56, 2, 2, 9366, 1263, 3, 2, 2, 2, 9367, 9374, 7, 31, 2, 2, 9368, 9369, 7, 271, 2, 2, 9369, 9370, 7, 4, 2, 2, 9370, 9371, 5, 686, 344, 2, 9371, 9372, 7, 5, 2, 2, 9372, 9374, 3, 2, 2, 2, 9373, 9367, 3, 2, 2, 2, 9373, 9368, 3, 2, 2, 2, 9374, 1265, 3, 2, 2, 2, 9375, 9382, 5, 1260, 631, 2, 9376, 9377, 7, 271, 2, 2, 9377, 9378, 7, 4, 2, 2, 9378, 9379, 5, 686, 344, 2, 9379, 9380, 7, 5, 2, 2, 9380, 9382, 3, 2, 2, 2, 9381, 9375, 3, 2, 2, 2, 9381, 9376, 3, 2, 2, 2, 9382, 1267, 3, 2, 2, 2, 9383, 9396, 5, 1260, 631, 2, 9384, 9385, 7, 271, 2, 2, 9385, 9386, 7, 4, 2, 2, 9386, 9387, 5, 686, 344, 2, 9387, 9388, 7, 5, 2, 2, 9388, 9396, 3, 2, 2, 2, 9389, 9396, 7, 122, 2, 2, 9390, 9391, 7, 79, 2, 2, 9391, 9396, 7, 122, 2, 2, 9392, 9396, 7, 116, 2, 2, 9393, 9394, 7, 79, 2, 2, 9394, 9396, 7, 116, 2, 2, 9395, 9383, 3, 2, 2, 2, 9395, 9384, 3, 2, 2, 2, 9395, 9389, 3, 2, 2, 2, 9395, 9390, 3, 2, 2, 2, 9395, 9392, 3, 2, 2, 2, 9395, 9393, 3, 2, 2, 2, 9396, 1269, 3, 2, 2, 2, 9397, 9402, 5, 1154, 578, 2, 9398, 9399, 7, 8, 2, 2, 9399, 9401, 5, 1154, 578, 2, 9400, 9398, 3, 2, 2, 2, 9401, 9404, 3, 2, 2, 2, 9402, 9400, 3, 2, 2, 2, 9402, 9403, 3, 2, 2, 2, 9403, 1271, 3, 2, 2, 2, 9404, 9402, 3, 2, 2, 2, 9405, 9410, 5, 1274, 638, 2, 9406, 9407, 7, 8, 2, 2, 9407, 9409, 5, 1274, 638, 2, 9408, 9406, 3, 2, 2, 2, 9409, 9412, 3, 2, 2, 2, 9410, 9408, 3, 2, 2, 2, 9410, 9411, 3, 2, 2, 2, 9411, 1273, 3, 2, 2, 2, 9412, 9410, 3, 2, 2, 2, 9413, 9419, 5, 1154, 578, 2, 9414, 9415, 5, 638, 320, 2, 9415, 9416, 9, 57, 2, 2, 9416, 9417, 5, 1154, 578, 2, 9417, 9419, 3, 2, 2, 2, 9418, 9413, 3, 2, 2, 2, 9418, 9414, 3, 2, 2, 2, 9419, 1275, 3, 2, 2, 2, 9420, 9425, 5, 1110, 556, 2, 9421, 9422, 7, 8, 2, 2, 9422, 9424, 5, 1110, 556, 2, 9423, 9421, 3, 2, 2, 2, 9424, 9427, 3, 2, 2, 2, 9425, 9423, 3, 2, 2, 2, 9425, 9426, 3, 2, 2, 2, 9426, 1277, 3, 2, 2, 2, 9427, 9425, 3, 2, 2, 2, 9428, 9431, 7, 6, 2, 2, 9429, 9432, 5, 1270, 636, 2, 9430, 9432, 5, 1280, 641, 2, 9431, 9429, 3, 2, 2, 2, 9431, 9430, 3, 2, 2, 2, 9431, 9432, 3, 2, 2, 2, 9432, 9433, 3, 2, 2, 2, 9433, 9434, 7, 7, 2, 2, 9434, 1279, 3, 2, 2, 2, 9435, 9440, 5, 1278, 640, 2, 9436, 9437, 7, 8, 2, 2, 9437, 9439, 5, 1278, 640, 2, 9438, 9436, 3, 2, 2, 2, 9439, 9442, 3, 2, 2, 2, 9440, 9438, 3, 2, 2, 2, 9440, 9441, 3, 2, 2, 2, 9441, 1281, 3, 2, 2, 2, 9442, 9440, 3, 2, 2, 2, 9443, 9444, 5, 1284, 643, 2, 9444, 9445, 7, 66, 2, 2, 9445, 9446, 5, 1154, 578, 2, 9446, 9449, 3, 2, 2, 2, 9447, 9449, 3, 2, 2, 2, 9448, 9443, 3, 2, 2, 2, 9448, 9447, 3, 2, 2, 2, 9449, 1283, 3, 2, 2, 2, 9450, 9459, 5, 1370, 686, 2, 9451, 9459, 7, 377, 2, 2, 9452, 9459, 7, 257, 2, 2, 9453, 9459, 7, 178, 2, 2, 9454, 9459, 7, 220, 2, 2, 9455, 9459, 7, 254, 2, 2, 9456, 9459, 7, 319, 2, 2, 9457, 9459, 5, 1348, 675, 2, 9458, 9450, 3, 2, 2, 2, 9458, 9451, 3, 2, 2, 2, 9458, 9452, 3, 2, 2, 2, 9458, 9453, 3, 2, 2, 2, 9458, 9454, 3, 2, 2, 2, 9458, 9455, 3, 2, 2, 2, 9458, 9456, 3, 2, 2, 2, 9458, 9457, 3, 2, 2, 2, 9459, 1285, 3, 2, 2, 2, 9460, 9461, 9, 58, 2, 2, 9461, 1287, 3, 2, 2, 2, 9462, 9463, 5, 1154, 578, 2, 9463, 9464, 7, 86, 2, 2, 9464, 9465, 5, 1154, 578, 2, 9465, 9466, 7, 66, 2, 2, 9466, 9469, 5, 1154, 578, 2, 9467, 9468, 7, 64, 2, 2, 9468, 9470, 5, 1154, 578, 2, 9469, 9467, 3, 2, 2, 2, 9469, 9470, 3, 2, 2, 2, 9470, 1289, 3, 2, 2, 2, 9471, 9472, 5, 1194, 598, 2, 9472, 9473, 7, 70, 2, 2, 9473, 9474, 5, 1194, 598, 2, 9474, 9477, 3, 2, 2, 2, 9475, 9477, 3, 2, 2, 2, 9476, 9471, 3, 2, 2, 2, 9476, 9475, 3, 2, 2, 2, 9477, 1291, 3, 2, 2, 2, 9478, 9479, 5, 1154, 578, 2, 9479, 9480, 7, 66, 2, 2, 9480, 9481, 5, 1154, 578, 2, 9481, 9482, 7, 64, 2, 2, 9482, 9483, 5, 1154, 578, 2, 9483, 9507, 3, 2, 2, 2, 9484, 9485, 5, 1154, 578, 2, 9485, 9486, 7, 64, 2, 2, 9486, 9487, 5, 1154, 578, 2, 9487, 9488, 7, 66, 2, 2, 9488, 9489, 5, 1154, 578, 2, 9489, 9507, 3, 2, 2, 2, 9490, 9491, 5, 1154, 578, 2, 9491, 9492, 7, 66, 2, 2, 9492, 9493, 5, 1154, 578, 2, 9493, 9507, 3, 2, 2, 2, 9494, 9495, 5, 1154, 578, 2, 9495, 9496, 7, 64, 2, 2, 9496, 9497, 5, 1154, 578, 2, 9497, 9507, 3, 2, 2, 2, 9498, 9499, 5, 1154, 578, 2, 9499, 9500, 7, 129, 2, 2, 9500, 9501, 5, 1154, 578, 2, 9501, 9502, 7, 199, 2, 2, 9502, 9503, 5, 1154, 578, 2, 9503, 9507, 3, 2, 2, 2, 9504, 9507, 5, 1270, 636, 2, 9505, 9507, 3, 2, 2, 2, 9506, 9478, 3, 2, 2, 2, 9506, 9484, 3, 2, 2, 2, 9506, 9490, 3, 2, 2, 2, 9506, 9494, 3, 2, 2, 2, 9506, 9498, 3, 2, 2, 2, 9506, 9504, 3, 2, 2, 2, 9506, 9505, 3, 2, 2, 2, 9507, 1293, 3, 2, 2, 2, 9508, 9509, 5, 1154, 578, 2, 9509, 9510, 7, 66, 2, 2, 9510, 9511, 5, 1270, 636, 2, 9511, 9516, 3, 2, 2, 2, 9512, 9513, 7, 66, 2, 2, 9513, 9516, 5, 1270, 636, 2, 9514, 9516, 5, 1270, 636, 2, 9515, 9508, 3, 2, 2, 2, 9515, 9512, 3, 2, 2, 2, 9515, 9514, 3, 2, 2, 2, 9516, 1295, 3, 2, 2, 2, 9517, 9523, 5, 956, 479, 2, 9518, 9519, 7, 4, 2, 2, 9519, 9520, 5, 1270, 636, 2, 9520, 9521, 7, 5, 2, 2, 9521, 9523, 3, 2, 2, 2, 9522, 9517, 3, 2, 2, 2, 9522, 9518, 3, 2, 2, 2, 9523, 1297, 3, 2, 2, 2, 9524, 9525, 7, 42, 2, 2, 9525, 9526, 5, 1306, 654, 2, 9526, 9527, 5, 1300, 651, 2, 9527, 9528, 5, 1304, 653, 2, 9528, 9529, 7, 447, 2, 2, 9529, 1299, 3, 2, 2, 2, 9530, 9532, 5, 1302, 652, 2, 9531, 9530, 3, 2, 2, 2, 9532, 9533, 3, 2, 2, 2, 9533, 9531, 3, 2, 2, 2, 9533, 9534, 3, 2, 2, 2, 9534, 1301, 3, 2, 2, 2, 9535, 9536, 7, 104, 2, 2, 9536, 9537, 5, 1154, 578, 2, 9537, 9538, 7, 95, 2, 2, 9538, 9539, 5, 1154, 578, 2, 9539, 1303, 3, 2, 2, 2, 9540, 9541, 7, 60, 2, 2, 9541, 9544, 5, 1154, 578, 2, 9542, 9544, 3, 2, 2, 2, 9543, 9540, 3, 2, 2, 2, 9543, 9542, 3, 2, 2, 2, 9544, 1305, 3, 2, 2, 2, 9545, 9548, 5, 1154, 578, 2, 9546, 9548, 3, 2, 2, 2, 9547, 9545, 3, 2, 2, 2, 9547, 9546, 3, 2, 2, 2, 9548, 1307, 3, 2, 2, 2, 9549, 9551, 5, 1362, 682, 2, 9550, 9552, 5, 1314, 658, 2, 9551, 9550, 3, 2, 2, 2, 9551, 9552, 3, 2, 2, 2, 9552, 1309, 3, 2, 2, 2, 9553, 9556, 7, 13, 2, 2, 9554, 9557, 5, 1332, 667, 2, 9555, 9557, 7, 11, 2, 2, 9556, 9554, 3, 2, 2, 2, 9556, 9555, 3, 2, 2, 2, 9557, 9569, 3, 2, 2, 2, 9558, 9564, 7, 6, 2, 2, 9559, 9565, 5, 1154, 578, 2, 9560, 9561, 5, 1312, 657, 2, 9561, 9562, 7, 10, 2, 2, 9562, 9563, 5, 1312, 657, 2, 9563, 9565, 3, 2, 2, 2, 9564, 9559, 3, 2, 2, 2, 9564, 9560, 3, 2, 2, 2, 9565, 9566, 3, 2, 2, 2, 9566, 9567, 7, 7, 2, 2, 9567, 9569, 3, 2, 2, 2, 9568, 9553, 3, 2, 2, 2, 9568, 9558, 3, 2, 2, 2, 9569, 1311, 3, 2, 2, 2, 9570, 9573, 5, 1154, 578, 2, 9571, 9573, 3, 2, 2, 2, 9572, 9570, 3, 2, 2, 2, 9572, 9571, 3, 2, 2, 2, 9573, 1313, 3, 2, 2, 2, 9574, 9576, 5, 1310, 656, 2, 9575, 9574, 3, 2, 2, 2, 9576, 9577, 3, 2, 2, 2, 9577, 9575, 3, 2, 2, 2, 9577, 9578, 3, 2, 2, 2, 9578, 1315, 3, 2, 2, 2, 9579, 9581, 5, 1310, 656, 2, 9580, 9579, 3, 2, 2, 2, 9581, 9584, 3, 2, 2, 2, 9582, 9580, 3, 2, 2, 2, 9582, 9583, 3, 2, 2, 2, 9583, 1317, 3, 2, 2, 2, 9584, 9582, 3, 2, 2, 2, 9585, 9588, 5, 1320, 661, 2, 9586, 9588, 3, 2, 2, 2, 9587, 9585, 3, 2, 2, 2, 9587, 9586, 3, 2, 2, 2, 9588, 1319, 3, 2, 2, 2, 9589, 9594, 5, 1322, 662, 2, 9590, 9591, 7, 8, 2, 2, 9591, 9593, 5, 1322, 662, 2, 9592, 9590, 3, 2, 2, 2, 9593, 9596, 3, 2, 2, 2, 9594, 9592, 3, 2, 2, 2, 9594, 9595, 3, 2, 2, 2, 9595, 1321, 3, 2, 2, 2, 9596, 9594, 3, 2, 2, 2, 9597, 9602, 5, 1154, 578, 2, 9598, 9599, 7, 38, 2, 2, 9599, 9603, 5, 1368, 685, 2, 9600, 9603, 5, 1370, 686, 2, 9601, 9603, 3, 2, 2, 2, 9602, 9598, 3, 2, 2, 2, 9602, 9600, 3, 2, 2, 2, 9602, 9601, 3, 2, 2, 2, 9603, 9606, 3, 2, 2, 2, 9604, 9606, 7, 11, 2, 2, 9605, 9597, 3, 2, 2, 2, 9605, 9604, 3, 2, 2, 2, 9606, 1323, 3, 2, 2, 2, 9607, 9612, 5, 1326, 664, 2, 9608, 9609, 7, 8, 2, 2, 9609, 9611, 5, 1326, 664, 2, 9610, 9608, 3, 2, 2, 2, 9611, 9614, 3, 2, 2, 2, 9612, 9610, 3, 2, 2, 2, 9612, 9613, 3, 2, 2, 2, 9613, 1325, 3, 2, 2, 2, 9614, 9612, 3, 2, 2, 2, 9615, 9617, 5, 1362, 682, 2, 9616, 9618, 5, 1314, 658, 2, 9617, 9616, 3, 2, 2, 2, 9617, 9618, 3, 2, 2, 2, 9618, 1327, 3, 2, 2, 2, 9619, 9624, 5, 1330, 666, 2, 9620, 9621, 7, 8, 2, 2, 9621, 9623, 5, 1330, 666, 2, 9622, 9620, 3, 2, 2, 2, 9623, 9626, 3, 2, 2, 2, 9624, 9622, 3, 2, 2, 2, 9624, 9625, 3, 2, 2, 2, 9625, 1329, 3, 2, 2, 2, 9626, 9624, 3, 2, 2, 2, 9627, 9628, 5, 1362, 682, 2, 9628, 1331, 3, 2, 2, 2, 9629, 9630, 5, 1368, 685, 2, 9630, 1333, 3, 2, 2, 2, 9631, 9632, 5, 1348, 675, 2, 9632, 1335, 3, 2, 2, 2, 9633, 9638, 5, 1364, 683, 2, 9634, 9635, 5, 1362, 682, 2, 9635, 9636, 5, 1314, 658, 2, 9636, 9638, 3, 2, 2, 2, 9637, 9633, 3, 2, 2, 2, 9637, 9634, 3, 2, 2, 2, 9638, 1337, 3, 2, 2, 2, 9639, 9672, 5, 1346, 674, 2, 9640, 9672, 5, 1344, 673, 2, 9641, 9672, 5, 1348, 675, 2, 9642, 9672, 5, 1342, 672, 2, 9643, 9672, 5, 1340, 671, 2, 9644, 9652, 5, 1336, 669, 2, 9645, 9653, 5, 1348, 675, 2, 9646, 9647, 7, 4, 2, 2, 9647, 9648, 5, 1272, 637, 2, 9648, 9649, 5, 992, 497, 2, 9649, 9650, 7, 5, 2, 2, 9650, 9651, 5, 1348, 675, 2, 9651, 9653, 3, 2, 2, 2, 9652, 9645, 3, 2, 2, 2, 9652, 9646, 3, 2, 2, 2, 9653, 9672, 3, 2, 2, 2, 9654, 9655, 5, 1116, 559, 2, 9655, 9656, 5, 1348, 675, 2, 9656, 9672, 3, 2, 2, 2, 9657, 9666, 5, 1144, 573, 2, 9658, 9659, 5, 1348, 675, 2, 9659, 9660, 5, 1148, 575, 2, 9660, 9667, 3, 2, 2, 2, 9661, 9662, 7, 4, 2, 2, 9662, 9663, 5, 1346, 674, 2, 9663, 9664, 7, 5, 2, 2, 9664, 9665, 5, 1348, 675, 2, 9665, 9667, 3, 2, 2, 2, 9666, 9658, 3, 2, 2, 2, 9666, 9661, 3, 2, 2, 2, 9667, 9672, 3, 2, 2, 2, 9668, 9672, 7, 98, 2, 2, 9669, 9672, 7, 62, 2, 2, 9670, 9672, 7, 80, 2, 2, 9671, 9639, 3, 2, 2, 2, 9671, 9640, 3, 2, 2, 2, 9671, 9641, 3, 2, 2, 2, 9671, 9642, 3, 2, 2, 2, 9671, 9643, 3, 2, 2, 2, 9671, 9644, 3, 2, 2, 2, 9671, 9654, 3, 2, 2, 2, 9671, 9657, 3, 2, 2, 2, 9671, 9668, 3, 2, 2, 2, 9671, 9669, 3, 2, 2, 2, 9671, 9670, 3, 2, 2, 2, 9672, 1339, 3, 2, 2, 2, 9673, 9674, 7, 532, 2, 2, 9674, 1341, 3, 2, 2, 2, 9675, 9676, 7, 528, 2, 2, 9676, 1343, 3, 2, 2, 2, 9677, 9678, 7, 538, 2, 2, 9678, 1345, 3, 2, 2, 2, 9679, 9680, 7, 536, 2, 2, 9680, 1347, 3, 2, 2, 2, 9681, 9682, 5, 1350, 676, 2, 9682, 9683, 5, 1352, 677, 2, 9683, 1349, 3, 2, 2, 2, 9684, 9696, 7, 523, 2, 2, 9685, 9696, 7, 525, 2, 2, 9686, 9690, 7, 527, 2, 2, 9687, 9689, 7, 555, 2, 2, 9688, 9687, 3, 2, 2, 2, 9689, 9692, 3, 2, 2, 2, 9690, 9688, 3, 2, 2, 2, 9690, 9691, 3, 2, 2, 2, 9691, 9693, 3, 2, 2, 2, 9692, 9690, 3, 2, 2, 2, 9693, 9696, 7, 556, 2, 2, 9694, 9696, 7, 549, 2, 2, 9695, 9684, 3, 2, 2, 2, 9695, 9685, 3, 2, 2, 2, 9695, 9686, 3, 2, 2, 2, 9695, 9694, 3, 2, 2, 2, 9696, 1351, 3, 2, 2, 2, 9697, 9698, 7, 480, 2, 2, 9698, 9701, 5, 1350, 676, 2, 9699, 9701, 3, 2, 2, 2, 9700, 9697, 3, 2, 2, 2, 9700, 9699, 3, 2, 2, 2, 9701, 1353, 3, 2, 2, 2, 9702, 9708, 5, 1346, 674, 2, 9703, 9704, 7, 14, 2, 2, 9704, 9708, 5, 1346, 674, 2, 9705, 9706, 7, 15, 2, 2, 9706, 9708, 5, 1346, 674, 2, 9707, 9702, 3, 2, 2, 2, 9707, 9703, 3, 2, 2, 2, 9707, 9705, 3, 2, 2, 2, 9708, 1355, 3, 2, 2, 2, 9709, 9710, 5, 1358, 680, 2, 9710, 1357, 3, 2, 2, 2, 9711, 9715, 5, 1366, 684, 2, 9712, 9715, 7, 54, 2, 2, 9713, 9715, 7, 91, 2, 2, 9714, 9711, 3, 2, 2, 2, 9714, 9712, 3, 2, 2, 2, 9714, 9713, 3, 2, 2, 2, 9715, 1359, 3, 2, 2, 2, 9716, 9721, 5, 1358, 680, 2, 9717, 9718, 7, 8, 2, 2, 9718, 9720, 5, 1358, 680, 2, 9719, 9717, 3, 2, 2, 2, 9720, 9723, 3, 2, 2, 2, 9721, 9719, 3, 2, 2, 2, 9721, 9722, 3, 2, 2, 2, 9722, 1361, 3, 2, 2, 2, 9723, 9721, 3, 2, 2, 2, 9724, 9729, 5, 1370, 686, 2, 9725, 9729, 5, 1374, 688, 2, 9726, 9729, 5, 1376, 689, 2, 9727, 9729, 5, 1594, 798, 2, 9728, 9724, 3, 2, 2, 2, 9728, 9725, 3, 2, 2, 2, 9728, 9726, 3, 2, 2, 2, 9728, 9727, 3, 2, 2, 2, 9729, 1363, 3, 2, 2, 2, 9730, 9735, 5, 1370, 686, 2, 9731, 9735, 5, 1374, 688, 2, 9732, 9735, 5, 1594, 798, 2, 9733, 9735, 5, 1378, 690, 2, 9734, 9730, 3, 2, 2, 2, 9734, 9731, 3, 2, 2, 2, 9734, 9732, 3, 2, 2, 2, 9734, 9733, 3, 2, 2, 2, 9735, 1365, 3, 2, 2, 2, 9736, 9741, 5, 1370, 686, 2, 9737, 9741, 5, 1374, 688, 2, 9738, 9741, 5, 1376, 689, 2, 9739, 9741, 5, 1378, 690, 2, 9740, 9736, 3, 2, 2, 2, 9740, 9737, 3, 2, 2, 2, 9740, 9738, 3, 2, 2, 2, 9740, 9739, 3, 2, 2, 2, 9741, 1367, 3, 2, 2, 2, 9742, 9749, 5, 1370, 686, 2, 9743, 9749, 5, 1594, 798, 2, 9744, 9749, 5, 1374, 688, 2, 9745, 9749, 5, 1376, 689, 2, 9746, 9749, 5, 1378, 690, 2, 9747, 9749, 5, 1380, 691, 2, 9748, 9742, 3, 2, 2, 2, 9748, 9743, 3, 2, 2, 2, 9748, 9744, 3, 2, 2, 2, 9748, 9745, 3, 2, 2, 2, 9748, 9746, 3, 2, 2, 2, 9748, 9747, 3, 2, 2, 2, 9749, 1369, 3, 2, 2, 2, 9750, 9751, 7, 514, 2, 2, 9751, 9758, 5, 1352, 677, 2, 9752, 9758, 7, 515, 2, 2, 9753, 9758, 7, 519, 2, 2, 9754, 9758, 5, 1198, 600, 2, 9755, 9758, 5, 1372, 687, 2, 9756, 9758, 5, 1594, 798, 2, 9757, 9750, 3, 2, 2, 2, 9757, 9752, 3, 2, 2, 2, 9757, 9753, 3, 2, 2, 2, 9757, 9754, 3, 2, 2, 2, 9757, 9755, 3, 2, 2, 2, 9757, 9756, 3, 2, 2, 2, 9758, 1371, 3, 2, 2, 2, 9759, 9760, 7, 540, 2, 2, 9760, 1373, 3, 2, 2, 2, 9761, 9762, 9, 59, 2, 2, 9762, 1375, 3, 2, 2, 2, 9763, 9815, 7, 380, 2, 2, 9764, 9815, 7, 381, 2, 2, 9765, 9815, 5, 1126, 564, 2, 9766, 9815, 7, 383, 2, 2, 9767, 9815, 7, 384, 2, 2, 9768, 9815, 5, 1134, 568, 2, 9769, 9815, 7, 386, 2, 2, 9770, 9815, 7, 387, 2, 2, 9771, 9815, 7, 388, 2, 2, 9772, 9815, 7, 389, 2, 2, 9773, 9815, 7, 390, 2, 2, 9774, 9815, 7, 391, 2, 2, 9775, 9815, 7, 392, 2, 2, 9776, 9815, 7, 463, 2, 2, 9777, 9815, 7, 393, 2, 2, 9778, 9815, 7, 394, 2, 2, 9779, 9815, 7, 395, 2, 2, 9780, 9815, 7, 396, 2, 2, 9781, 9815, 7, 397, 2, 2, 9782, 9815, 7, 398, 2, 2, 9783, 9815, 7, 399, 2, 2, 9784, 9815, 7, 400, 2, 2, 9785, 9815, 7, 482, 2, 2, 9786, 9815, 7, 401, 2, 2, 9787, 9815, 5, 1122, 562, 2, 9788, 9815, 7, 446, 2, 2, 9789, 9815, 7, 403, 2, 2, 9790, 9815, 7, 404, 2, 2, 9791, 9815, 7, 405, 2, 2, 9792, 9815, 7, 406, 2, 2, 9793, 9815, 7, 407, 2, 2, 9794, 9815, 7, 408, 2, 2, 9795, 9815, 7, 409, 2, 2, 9796, 9815, 7, 410, 2, 2, 9797, 9815, 7, 411, 2, 2, 9798, 9815, 7, 412, 2, 2, 9799, 9815, 7, 413, 2, 2, 9800, 9815, 7, 414, 2, 2, 9801, 9815, 7, 415, 2, 2, 9802, 9815, 7, 416, 2, 2, 9803, 9815, 7, 417, 2, 2, 9804, 9815, 7, 418, 2, 2, 9805, 9815, 7, 419, 2, 2, 9806, 9815, 7, 420, 2, 2, 9807, 9815, 7, 421, 2, 2, 9808, 9815, 7, 469, 2, 2, 9809, 9815, 7, 422, 2, 2, 9810, 9815, 7, 423, 2, 2, 9811, 9815, 7, 424, 2, 2, 9812, 9815, 7, 425, 2, 2, 9813, 9815, 7, 467, 2, 2, 9814, 9763, 3, 2, 2, 2, 9814, 9764, 3, 2, 2, 2, 9814, 9765, 3, 2, 2, 2, 9814, 9766, 3, 2, 2, 2, 9814, 9767, 3, 2, 2, 2, 9814, 9768, 3, 2, 2, 2, 9814, 9769, 3, 2, 2, 2, 9814, 9770, 3, 2, 2, 2, 9814, 9771, 3, 2, 2, 2, 9814, 9772, 3, 2, 2, 2, 9814, 9773, 3, 2, 2, 2, 9814, 9774, 3, 2, 2, 2, 9814, 9775, 3, 2, 2, 2, 9814, 9776, 3, 2, 2, 2, 9814, 9777, 3, 2, 2, 2, 9814, 9778, 3, 2, 2, 2, 9814, 9779, 3, 2, 2, 2, 9814, 9780, 3, 2, 2, 2, 9814, 9781, 3, 2, 2, 2, 9814, 9782, 3, 2, 2, 2, 9814, 9783, 3, 2, 2, 2, 9814, 9784, 3, 2, 2, 2, 9814, 9785, 3, 2, 2, 2, 9814, 9786, 3, 2, 2, 2, 9814, 9787, 3, 2, 2, 2, 9814, 9788, 3, 2, 2, 2, 9814, 9789, 3, 2, 2, 2, 9814, 9790, 3, 2, 2, 2, 9814, 9791, 3, 2, 2, 2, 9814, 9792, 3, 2, 2, 2, 9814, 9793, 3, 2, 2, 2, 9814, 9794, 3, 2, 2, 2, 9814, 9795, 3, 2, 2, 2, 9814, 9796, 3, 2, 2, 2, 9814, 9797, 3, 2, 2, 2, 9814, 9798, 3, 2, 2, 2, 9814, 9799, 3, 2, 2, 2, 9814, 9800, 3, 2, 2, 2, 9814, 9801, 3, 2, 2, 2, 9814, 9802, 3, 2, 2, 2, 9814, 9803, 3, 2, 2, 2, 9814, 9804, 3, 2, 2, 2, 9814, 9805, 3, 2, 2, 2, 9814, 9806, 3, 2, 2, 2, 9814, 9807, 3, 2, 2, 2, 9814, 9808, 3, 2, 2, 2, 9814, 9809, 3, 2, 2, 2, 9814, 9810, 3, 2, 2, 2, 9814, 9811, 3, 2, 2, 2, 9814, 9812, 3, 2, 2, 2, 9814, 9813, 3, 2, 2, 2, 9815, 1377, 3, 2, 2, 2, 9816, 9817, 9, 60, 2, 2, 9817, 1379, 3, 2, 2, 2, 9818, 9819, 9, 61, 2, 2, 9819, 1381, 3, 2, 2, 2, 9820, 9821, 5, 1384, 693, 2, 9821, 9822, 5, 1394, 698, 2, 9822, 9823, 5, 1392, 697, 2, 9823, 1383, 3, 2, 2, 2, 9824, 9826, 5, 1386, 694, 2, 9825, 9824, 3, 2, 2, 2, 9826, 9829, 3, 2, 2, 2, 9827, 9825, 3, 2, 2, 2, 9827, 9828, 3, 2, 2, 2, 9828, 1385, 3, 2, 2, 2, 9829, 9827, 3, 2, 2, 2, 9830, 9831, 5, 1388, 695, 2, 9831, 9832, 7, 272, 2, 2, 9832, 9833, 7, 483, 2, 2, 9833, 9851, 3, 2, 2, 2, 9834, 9835, 5, 1388, 695, 2, 9835, 9836, 7, 484, 2, 2, 9836, 9837, 5, 1390, 696, 2, 9837, 9851, 3, 2, 2, 2, 9838, 9839, 5, 1388, 695, 2, 9839, 9840, 7, 485, 2, 2, 9840, 9841, 7, 486, 2, 2, 9841, 9851, 3, 2, 2, 2, 9842, 9843, 5, 1388, 695, 2, 9843, 9844, 7, 485, 2, 2, 9844, 9845, 7, 487, 2, 2, 9845, 9851, 3, 2, 2, 2, 9846, 9847, 5, 1388, 695, 2, 9847, 9848, 7, 485, 2, 2, 9848, 9849, 7, 488, 2, 2, 9849, 9851, 3, 2, 2, 2, 9850, 9830, 3, 2, 2, 2, 9850, 9834, 3, 2, 2, 2, 9850, 9838, 3, 2, 2, 2, 9850, 9842, 3, 2, 2, 2, 9850, 9846, 3, 2, 2, 2, 9851, 1387, 3, 2, 2, 2, 9852, 9853, 7, 31, 2, 2, 9853, 1389, 3, 2, 2, 2, 9854, 9859, 5, 1348, 675, 2, 9855, 9859, 5, 1380, 691, 2, 9856, 9859, 5, 1594, 798, 2, 9857, 9859, 5, 1374, 688, 2, 9858, 9854, 3, 2, 2, 2, 9858, 9855, 3, 2, 2, 2, 9858, 9856, 3, 2, 2, 2, 9858, 9857, 3, 2, 2, 2, 9859, 1391, 3, 2, 2, 2, 9860, 9863, 3, 2, 2, 2, 9861, 9863, 7, 9, 2, 2, 9862, 9860, 3, 2, 2, 2, 9862, 9861, 3, 2, 2, 2, 9863, 1393, 3, 2, 2, 2, 9864, 9865, 5, 1396, 699, 2, 9865, 9866, 7, 148, 2, 2, 9866, 9867, 5, 1438, 720, 2, 9867, 9868, 5, 1574, 788, 2, 9868, 9869, 7, 447, 2, 2, 9869, 9870, 5, 1588, 795, 2, 9870, 1395, 3, 2, 2, 2, 9871, 9876, 5, 1584, 793, 2, 9872, 9874, 5, 1398, 700, 2, 9873, 9875, 5, 1400, 701, 2, 9874, 9873, 3, 2, 2, 2, 9874, 9875, 3, 2, 2, 2, 9875, 9877, 3, 2, 2, 2, 9876, 9872, 3, 2, 2, 2, 9876, 9877, 3, 2, 2, 2, 9877, 1397, 3, 2, 2, 2, 9878, 9879, 7, 180, 2, 2, 9879, 1399, 3, 2, 2, 2, 9880, 9882, 5, 1404, 703, 2, 9881, 9880, 3, 2, 2, 2, 9882, 9883, 3, 2, 2, 2, 9883, 9881, 3, 2, 2, 2, 9883, 9884, 3, 2, 2, 2, 9884, 1401, 3, 2, 2, 2, 9885, 9886, 7, 20, 2, 2, 9886, 9887, 5, 1592, 797, 2, 9887, 9888, 7, 21, 2, 2, 9888, 1403, 3, 2, 2, 2, 9889, 9893, 5, 1406, 704, 2, 9890, 9893, 7, 180, 2, 2, 9891, 9893, 5, 1402, 702, 2, 9892, 9889, 3, 2, 2, 2, 9892, 9890, 3, 2, 2, 2, 9892, 9891, 3, 2, 2, 2, 9893, 1405, 3, 2, 2, 2, 9894, 9910, 5, 1422, 712, 2, 9895, 9896, 7, 489, 2, 2, 9896, 9897, 7, 64, 2, 2, 9897, 9911, 5, 1420, 711, 2, 9898, 9899, 5, 1424, 713, 2, 9899, 9900, 5, 1426, 714, 2, 9900, 9901, 5, 1428, 715, 2, 9901, 9902, 5, 1430, 716, 2, 9902, 9903, 5, 1432, 717, 2, 9903, 9911, 3, 2, 2, 2, 9904, 9905, 5, 1408, 705, 2, 9905, 9906, 7, 174, 2, 2, 9906, 9907, 5, 1412, 707, 2, 9907, 9908, 5, 1418, 710, 2, 9908, 9909, 5, 1410, 706, 2, 9909, 9911, 3, 2, 2, 2, 9910, 9895, 3, 2, 2, 2, 9910, 9898, 3, 2, 2, 2, 9910, 9904, 3, 2, 2, 2, 9911, 9912, 3, 2, 2, 2, 9912, 9913, 7, 9, 2, 2, 9913, 1407, 3, 2, 2, 2, 9914, 9919, 3, 2, 2, 2, 9915, 9916, 7, 262, 2, 2, 9916, 9919, 7, 317, 2, 2, 9917, 9919, 7, 317, 2, 2, 9918, 9914, 3, 2, 2, 2, 9918, 9915, 3, 2, 2, 2, 9918, 9917, 3, 2, 2, 2, 9919, 1409, 3, 2, 2, 2, 9920, 9921, 5, 954, 478, 2, 9921, 1411, 3, 2, 2, 2, 9922, 9928, 3, 2, 2, 2, 9923, 9924, 7, 4, 2, 2, 9924, 9925, 5, 1414, 708, 2, 9925, 9926, 7, 5, 2, 2, 9926, 9928, 3, 2, 2, 2, 9927, 9922, 3, 2, 2, 2, 9927, 9923, 3, 2, 2, 2, 9928, 1413, 3, 2, 2, 2, 9929, 9934, 5, 1416, 709, 2, 9930, 9931, 7, 8, 2, 2, 9931, 9933, 5, 1416, 709, 2, 9932, 9930, 3, 2, 2, 2, 9933, 9936, 3, 2, 2, 2, 9934, 9932, 3, 2, 2, 2, 9934, 9935, 3, 2, 2, 2, 9935, 1415, 3, 2, 2, 2, 9936, 9934, 3, 2, 2, 2, 9937, 9938, 5, 1422, 712, 2, 9938, 9939, 5, 1426, 714, 2, 9939, 1417, 3, 2, 2, 2, 9940, 9941, 9, 62, 2, 2, 9941, 1419, 3, 2, 2, 2, 9942, 9945, 7, 30, 2, 2, 9943, 9945, 5, 1362, 682, 2, 9944, 9942, 3, 2, 2, 2, 9944, 9943, 3, 2, 2, 2, 9945, 1421, 3, 2, 2, 2, 9946, 9947, 5, 1592, 797, 2, 9947, 1423, 3, 2, 2, 2, 9948, 9951, 3, 2, 2, 2, 9949, 9951, 7, 490, 2, 2, 9950, 9948, 3, 2, 2, 2, 9950, 9949, 3, 2, 2, 2, 9951, 1425, 3, 2, 2, 2, 9952, 9953, 5, 1110, 556, 2, 9953, 1427, 3, 2, 2, 2, 9954, 9958, 3, 2, 2, 2, 9955, 9956, 7, 45, 2, 2, 9956, 9958, 5, 526, 264, 2, 9957, 9954, 3, 2, 2, 2, 9957, 9955, 3, 2, 2, 2, 9958, 1429, 3, 2, 2, 2, 9959, 9963, 3, 2, 2, 2, 9960, 9961, 7, 79, 2, 2, 9961, 9963, 7, 80, 2, 2, 9962, 9959, 3, 2, 2, 2, 9962, 9960, 3, 2, 2, 2, 9963, 1431, 3, 2, 2, 2, 9964, 9969, 3, 2, 2, 2, 9965, 9966, 5, 1434, 718, 2, 9966, 9967, 5, 1596, 799, 2, 9967, 9969, 3, 2, 2, 2, 9968, 9964, 3, 2, 2, 2, 9968, 9965, 3, 2, 2, 2, 9969, 1433, 3, 2, 2, 2, 9970, 9973, 5, 1436, 719, 2, 9971, 9973, 7, 55, 2, 2, 9972, 9970, 3, 2, 2, 2, 9972, 9971, 3, 2, 2, 2, 9973, 1435, 3, 2, 2, 2, 9974, 9975, 9, 63, 2, 2, 9975, 1437, 3, 2, 2, 2, 9976, 9978, 5, 1440, 721, 2, 9977, 9976, 3, 2, 2, 2, 9978, 9981, 3, 2, 2, 2, 9979, 9977, 3, 2, 2, 2, 9979, 9980, 3, 2, 2, 2, 9980, 1439, 3, 2, 2, 2, 9981, 9979, 3, 2, 2, 2, 9982, 9983, 5, 1394, 698, 2, 9983, 9984, 7, 9, 2, 2, 9984, 10010, 3, 2, 2, 2, 9985, 10010, 5, 1506, 754, 2, 9986, 10010, 5, 1510, 756, 2, 9987, 10010, 5, 1448, 725, 2, 9988, 10010, 5, 1464, 733, 2, 9989, 10010, 5, 1470, 736, 2, 9990, 10010, 5, 1480, 741, 2, 9991, 10010, 5, 1482, 742, 2, 9992, 10010, 5, 1484, 743, 2, 9993, 10010, 5, 1498, 750, 2, 9994, 10010, 5, 1502, 752, 2, 9995, 10010, 5, 1522, 762, 2, 9996, 10010, 5, 1528, 765, 2, 9997, 10010, 5, 1530, 766, 2, 9998, 10010, 5, 1442, 722, 2, 9999, 10010, 5, 1444, 723, 2, 10000, 10010, 5, 1450, 726, 2, 10001, 10010, 5, 1538, 770, 2, 10002, 10010, 5, 1550, 776, 2, 10003, 10010, 5, 1558, 780, 2, 10004, 10010, 5, 1560, 781, 2, 10005, 10010, 5, 1562, 782, 2, 10006, 10010, 5, 1564, 783, 2, 10007, 10010, 5, 1566, 784, 2, 10008, 10010, 5, 1570, 786, 2, 10009, 9982, 3, 2, 2, 2, 10009, 9985, 3, 2, 2, 2, 10009, 9986, 3, 2, 2, 2, 10009, 9987, 3, 2, 2, 2, 10009, 9988, 3, 2, 2, 2, 10009, 9989, 3, 2, 2, 2, 10009, 9990, 3, 2, 2, 2, 10009, 9991, 3, 2, 2, 2, 10009, 9992, 3, 2, 2, 2, 10009, 9993, 3, 2, 2, 2, 10009, 9994, 3, 2, 2, 2, 10009, 9995, 3, 2, 2, 2, 10009, 9996, 3, 2, 2, 2, 10009, 9997, 3, 2, 2, 2, 10009, 9998, 3, 2, 2, 2, 10009, 9999, 3, 2, 2, 2, 10009, 10000, 3, 2, 2, 2, 10009, 10001, 3, 2, 2, 2, 10009, 10002, 3, 2, 2, 2, 10009, 10003, 3, 2, 2, 2, 10009, 10004, 3, 2, 2, 2, 10009, 10005, 3, 2, 2, 2, 10009, 10006, 3, 2, 2, 2, 10009, 10007, 3, 2, 2, 2, 10009, 10008, 3, 2, 2, 2, 10010, 1441, 3, 2, 2, 2, 10011, 10012, 7, 491, 2, 2, 10012, 10013, 5, 1600, 801, 2, 10013, 10014, 7, 9, 2, 2, 10014, 1443, 3, 2, 2, 2, 10015, 10016, 7, 426, 2, 2, 10016, 10017, 5, 1592, 797, 2, 10017, 10018, 7, 4, 2, 2, 10018, 10019, 5, 1446, 724, 2, 10019, 10020, 7, 5, 2, 2, 10020, 10021, 7, 9, 2, 2, 10021, 10030, 3, 2, 2, 2, 10022, 10023, 7, 59, 2, 2, 10023, 10024, 5, 1592, 797, 2, 10024, 10025, 7, 4, 2, 2, 10025, 10026, 5, 1446, 724, 2, 10026, 10027, 7, 5, 2, 2, 10027, 10028, 7, 9, 2, 2, 10028, 10030, 3, 2, 2, 2, 10029, 10015, 3, 2, 2, 2, 10029, 10022, 3, 2, 2, 2, 10030, 1445, 3, 2, 2, 2, 10031, 10034, 3, 2, 2, 2, 10032, 10034, 5, 1270, 636, 2, 10033, 10031, 3, 2, 2, 2, 10033, 10032, 3, 2, 2, 2, 10034, 1447, 3, 2, 2, 2, 10035, 10036, 5, 1462, 732, 2, 10036, 10037, 5, 1436, 719, 2, 10037, 10038, 5, 1596, 799, 2, 10038, 10039, 7, 9, 2, 2, 10039, 1449, 3, 2, 2, 2, 10040, 10041, 7, 492, 2, 2, 10041, 10042, 5, 1452, 727, 2, 10042, 10043, 7, 493, 2, 2, 10043, 10044, 5, 1454, 728, 2, 10044, 10045, 7, 9, 2, 2, 10045, 1451, 3, 2, 2, 2, 10046, 10050, 3, 2, 2, 2, 10047, 10050, 7, 427, 2, 2, 10048, 10050, 7, 494, 2, 2, 10049, 10046, 3, 2, 2, 2, 10049, 10047, 3, 2, 2, 2, 10049, 10048, 3, 2, 2, 2, 10050, 1453, 3, 2, 2, 2, 10051, 10056, 5, 1456, 729, 2, 10052, 10053, 7, 8, 2, 2, 10053, 10055, 5, 1456, 729, 2, 10054, 10052, 3, 2, 2, 2, 10055, 10058, 3, 2, 2, 2, 10056, 10054, 3, 2, 2, 2, 10056, 10057, 3, 2, 2, 2, 10057, 1455, 3, 2, 2, 2, 10058, 10056, 3, 2, 2, 2, 10059, 10060, 5, 1460, 731, 2, 10060, 10061, 5, 1436, 719, 2, 10061, 10062, 5, 1458, 730, 2, 10062, 1457, 3, 2, 2, 2, 10063, 10064, 5, 1362, 682, 2, 10064, 1459, 3, 2, 2, 2, 10065, 10066, 5, 1462, 732, 2, 10066, 1461, 3, 2, 2, 2, 10067, 10070, 5, 526, 264, 2, 10068, 10070, 7, 30, 2, 2, 10069, 10067, 3, 2, 2, 2, 10069, 10068, 3, 2, 2, 2, 10070, 10077, 3, 2, 2, 2, 10071, 10072, 7, 6, 2, 2, 10072, 10073, 5, 1602, 802, 2, 10073, 10074, 7, 7, 2, 2, 10074, 10076, 3, 2, 2, 2, 10075, 10071, 3, 2, 2, 2, 10076, 10079, 3, 2, 2, 2, 10077, 10075, 3, 2, 2, 2, 10077, 10078, 3, 2, 2, 2, 10078, 1463, 3, 2, 2, 2, 10079, 10077, 3, 2, 2, 2, 10080, 10081, 7, 222, 2, 2, 10081, 10082, 5, 1598, 800, 2, 10082, 10083, 7, 95, 2, 2, 10083, 10084, 5, 1438, 720, 2, 10084, 10085, 5, 1466, 734, 2, 10085, 10086, 5, 1468, 735, 2, 10086, 10087, 7, 447, 2, 2, 10087, 10088, 7, 222, 2, 2, 10088, 10089, 7, 9, 2, 2, 10089, 1465, 3, 2, 2, 2, 10090, 10091, 7, 495, 2, 2, 10091, 10092, 5, 1154, 578, 2, 10092, 10093, 7, 95, 2, 2, 10093, 10094, 5, 1438, 720, 2, 10094, 10096, 3, 2, 2, 2, 10095, 10090, 3, 2, 2, 2, 10096, 10099, 3, 2, 2, 2, 10097, 10095, 3, 2, 2, 2, 10097, 10098, 3, 2, 2, 2, 10098, 1467, 3, 2, 2, 2, 10099, 10097, 3, 2, 2, 2, 10100, 10104, 3, 2, 2, 2, 10101, 10102, 7, 60, 2, 2, 10102, 10104, 5, 1438, 720, 2, 10103, 10100, 3, 2, 2, 2, 10103, 10101, 3, 2, 2, 2, 10104, 1469, 3, 2, 2, 2, 10105, 10106, 7, 42, 2, 2, 10106, 10107, 5, 1472, 737, 2, 10107, 10108, 5, 1474, 738, 2, 10108, 10109, 5, 1478, 740, 2, 10109, 10110, 7, 447, 2, 2, 10110, 10111, 7, 42, 2, 2, 10111, 10112, 7, 9, 2, 2, 10112, 1471, 3, 2, 2, 2, 10113, 10116, 3, 2, 2, 2, 10114, 10116, 5, 1596, 799, 2, 10115, 10113, 3, 2, 2, 2, 10115, 10114, 3, 2, 2, 2, 10116, 1473, 3, 2, 2, 2, 10117, 10119, 5, 1476, 739, 2, 10118, 10117, 3, 2, 2, 2, 10119, 10120, 3, 2, 2, 2, 10120, 10118, 3, 2, 2, 2, 10120, 10121, 3, 2, 2, 2, 10121, 1475, 3, 2, 2, 2, 10122, 10123, 7, 104, 2, 2, 10123, 10124, 5, 1270, 636, 2, 10124, 10125, 7, 95, 2, 2, 10125, 10126, 5, 1438, 720, 2, 10126, 1477, 3, 2, 2, 2, 10127, 10131, 3, 2, 2, 2, 10128, 10129, 7, 60, 2, 2, 10129, 10131, 5, 1438, 720, 2, 10130, 10127, 3, 2, 2, 2, 10130, 10128, 3, 2, 2, 2, 10131, 1479, 3, 2, 2, 2, 10132, 10133, 5, 1586, 794, 2, 10133, 10134, 5, 1526, 764, 2, 10134, 1481, 3, 2, 2, 2, 10135, 10136, 5, 1586, 794, 2, 10136, 10137, 7, 496, 2, 2, 10137, 10138, 5, 1604, 803, 2, 10138, 10139, 5, 1526, 764, 2, 10139, 1483, 3, 2, 2, 2, 10140, 10141, 5, 1586, 794, 2, 10141, 10142, 7, 64, 2, 2, 10142, 10143, 5, 1486, 744, 2, 10143, 10144, 5, 1526, 764, 2, 10144, 1485, 3, 2, 2, 2, 10145, 10146, 5, 1496, 749, 2, 10146, 10162, 7, 70, 2, 2, 10147, 10148, 5, 948, 475, 2, 10148, 10149, 5, 1490, 746, 2, 10149, 10163, 3, 2, 2, 2, 10150, 10163, 5, 954, 478, 2, 10151, 10163, 5, 880, 441, 2, 10152, 10153, 7, 204, 2, 2, 10153, 10154, 5, 1154, 578, 2, 10154, 10155, 5, 1488, 745, 2, 10155, 10163, 3, 2, 2, 2, 10156, 10157, 5, 1492, 747, 2, 10157, 10158, 5, 1154, 578, 2, 10158, 10159, 7, 26, 2, 2, 10159, 10160, 5, 1154, 578, 2, 10160, 10161, 5, 1494, 748, 2, 10161, 10163, 3, 2, 2, 2, 10162, 10147, 3, 2, 2, 2, 10162, 10150, 3, 2, 2, 2, 10162, 10151, 3, 2, 2, 2, 10162, 10152, 3, 2, 2, 2, 10162, 10156, 3, 2, 2, 2, 10163, 1487, 3, 2, 2, 2, 10164, 10168, 3, 2, 2, 2, 10165, 10166, 7, 102, 2, 2, 10166, 10168, 5, 1270, 636, 2, 10167, 10164, 3, 2, 2, 2, 10167, 10165, 3, 2, 2, 2, 10168, 1489, 3, 2, 2, 2, 10169, 10182, 3, 2, 2, 2, 10170, 10171, 7, 4, 2, 2, 10171, 10176, 5, 1154, 578, 2, 10172, 10173, 7, 8, 2, 2, 10173, 10175, 5, 1154, 578, 2, 10174, 10172, 3, 2, 2, 2, 10175, 10178, 3, 2, 2, 2, 10176, 10174, 3, 2, 2, 2, 10176, 10177, 3, 2, 2, 2, 10177, 10179, 3, 2, 2, 2, 10178, 10176, 3, 2, 2, 2, 10179, 10180, 7, 5, 2, 2, 10180, 10182, 3, 2, 2, 2, 10181, 10169, 3, 2, 2, 2, 10181, 10170, 3, 2, 2, 2, 10182, 1491, 3, 2, 2, 2, 10183, 10186, 3, 2, 2, 2, 10184, 10186, 7, 497, 2, 2, 10185, 10183, 3, 2, 2, 2, 10185, 10184, 3, 2, 2, 2, 10186, 1493, 3, 2, 2, 2, 10187, 10191, 3, 2, 2, 2, 10188, 10189, 7, 149, 2, 2, 10189, 10191, 5, 1154, 578, 2, 10190, 10187, 3, 2, 2, 2, 10190, 10188, 3, 2, 2, 2, 10191, 1495, 3, 2, 2, 2, 10192, 10193, 5, 524, 263, 2, 10193, 1497, 3, 2, 2, 2, 10194, 10195, 5, 1586, 794, 2, 10195, 10196, 7, 498, 2, 2, 10196, 10197, 5, 1496, 749, 2, 10197, 10198, 5, 1500, 751, 2, 10198, 10199, 7, 70, 2, 2, 10199, 10200, 7, 37, 2, 2, 10200, 10201, 5, 1154, 578, 2, 10201, 10202, 5, 1526, 764, 2, 10202, 1499, 3, 2, 2, 2, 10203, 10207, 3, 2, 2, 2, 10204, 10205, 7, 499, 2, 2, 10205, 10207, 5, 1346, 674, 2, 10206, 10203, 3, 2, 2, 2, 10206, 10204, 3, 2, 2, 2, 10207, 1501, 3, 2, 2, 2, 10208, 10209, 5, 1504, 753, 2, 10209, 10210, 5, 1588, 795, 2, 10210, 10211, 5, 1590, 796, 2, 10211, 10212, 7, 9, 2, 2, 10212, 1503, 3, 2, 2, 2, 10213, 10214, 9, 64, 2, 2, 10214, 1505, 3, 2, 2, 2, 10215, 10227, 7, 501, 2, 2, 10216, 10217, 7, 261, 2, 2, 10217, 10228, 5, 1596, 799, 2, 10218, 10224, 7, 502, 2, 2, 10219, 10220, 7, 204, 2, 2, 10220, 10221, 5, 1154, 578, 2, 10221, 10222, 5, 1488, 745, 2, 10222, 10225, 3, 2, 2, 2, 10223, 10225, 5, 954, 478, 2, 10224, 10219, 3, 2, 2, 2, 10224, 10223, 3, 2, 2, 2, 10225, 10228, 3, 2, 2, 2, 10226, 10228, 5, 1508, 755, 2, 10227, 10216, 3, 2, 2, 2, 10227, 10218, 3, 2, 2, 2, 10227, 10226, 3, 2, 2, 2, 10228, 10229, 3, 2, 2, 2, 10229, 10230, 7, 9, 2, 2, 10230, 1507, 3, 2, 2, 2, 10231, 10234, 3, 2, 2, 2, 10232, 10234, 5, 1596, 799, 2, 10233, 10231, 3, 2, 2, 2, 10233, 10232, 3, 2, 2, 2, 10234, 1509, 3, 2, 2, 2, 10235, 10236, 7, 503, 2, 2, 10236, 10237, 5, 1512, 757, 2, 10237, 10238, 5, 1348, 675, 2, 10238, 10239, 5, 1514, 758, 2, 10239, 10240, 5, 1516, 759, 2, 10240, 10241, 7, 9, 2, 2, 10241, 10262, 3, 2, 2, 2, 10242, 10243, 7, 503, 2, 2, 10243, 10244, 5, 1512, 757, 2, 10244, 10245, 5, 1370, 686, 2, 10245, 10246, 5, 1516, 759, 2, 10246, 10247, 7, 9, 2, 2, 10247, 10262, 3, 2, 2, 2, 10248, 10249, 7, 503, 2, 2, 10249, 10250, 5, 1512, 757, 2, 10250, 10251, 7, 504, 2, 2, 10251, 10252, 5, 1348, 675, 2, 10252, 10253, 5, 1516, 759, 2, 10253, 10254, 7, 9, 2, 2, 10254, 10262, 3, 2, 2, 2, 10255, 10256, 7, 503, 2, 2, 10256, 10257, 5, 1512, 757, 2, 10257, 10258, 5, 1516, 759, 2, 10258, 10259, 7, 9, 2, 2, 10259, 10262, 3, 2, 2, 2, 10260, 10262, 7, 503, 2, 2, 10261, 10235, 3, 2, 2, 2, 10261, 10242, 3, 2, 2, 2, 10261, 10248, 3, 2, 2, 2, 10261, 10255, 3, 2, 2, 2, 10261, 10260, 3, 2, 2, 2, 10262, 1511, 3, 2, 2, 2, 10263, 10272, 3, 2, 2, 2, 10264, 10272, 3, 2, 2, 2, 10265, 10272, 7, 505, 2, 2, 10266, 10272, 7, 506, 2, 2, 10267, 10272, 7, 507, 2, 2, 10268, 10272, 7, 508, 2, 2, 10269, 10272, 7, 509, 2, 2, 10270, 10272, 7, 510, 2, 2, 10271, 10263, 3, 2, 2, 2, 10271, 10264, 3, 2, 2, 2, 10271, 10265, 3, 2, 2, 2, 10271, 10266, 3, 2, 2, 2, 10271, 10267, 3, 2, 2, 2, 10271, 10268, 3, 2, 2, 2, 10271, 10269, 3, 2, 2, 2, 10271, 10270, 3, 2, 2, 2, 10272, 1513, 3, 2, 2, 2, 10273, 10281, 3, 2, 2, 2, 10274, 10275, 7, 8, 2, 2, 10275, 10277, 5, 1154, 578, 2, 10276, 10274, 3, 2, 2, 2, 10277, 10278, 3, 2, 2, 2, 10278, 10276, 3, 2, 2, 2, 10278, 10279, 3, 2, 2, 2, 10279, 10281, 3, 2, 2, 2, 10280, 10273, 3, 2, 2, 2, 10280, 10276, 3, 2, 2, 2, 10281, 1515, 3, 2, 2, 2, 10282, 10286, 3, 2, 2, 2, 10283, 10284, 7, 102, 2, 2, 10284, 10286, 5, 1520, 761, 2, 10285, 10282, 3, 2, 2, 2, 10285, 10283, 3, 2, 2, 2, 10286, 1517, 3, 2, 2, 2, 10287, 10288, 5, 1370, 686, 2, 10288, 10289, 7, 12, 2, 2, 10289, 10290, 5, 1154, 578, 2, 10290, 1519, 3, 2, 2, 2, 10291, 10296, 5, 1518, 760, 2, 10292, 10293, 7, 8, 2, 2, 10293, 10295, 5, 1518, 760, 2, 10294, 10292, 3, 2, 2, 2, 10295, 10298, 3, 2, 2, 2, 10296, 10294, 3, 2, 2, 2, 10296, 10297, 3, 2, 2, 2, 10297, 1521, 3, 2, 2, 2, 10298, 10296, 3, 2, 2, 2, 10299, 10300, 7, 511, 2, 2, 10300, 10301, 5, 1596, 799, 2, 10301, 10302, 5, 1524, 763, 2, 10302, 10303, 7, 9, 2, 2, 10303, 1523, 3, 2, 2, 2, 10304, 10308, 3, 2, 2, 2, 10305, 10306, 7, 8, 2, 2, 10306, 10308, 5, 1596, 799, 2, 10307, 10304, 3, 2, 2, 2, 10307, 10305, 3, 2, 2, 2, 10308, 1525, 3, 2, 2, 2, 10309, 10310, 7, 512, 2, 2, 10310, 10311, 5, 1438, 720, 2, 10311, 10312, 7, 447, 2, 2, 10312, 10313, 7, 512, 2, 2, 10313, 10314, 5, 1588, 795, 2, 10314, 10315, 7, 9, 2, 2, 10315, 1527, 3, 2, 2, 2, 10316, 10317, 5, 1606, 804, 2, 10317, 10318, 7, 9, 2, 2, 10318, 1529, 3, 2, 2, 2, 10319, 10320, 7, 204, 2, 2, 10320, 10328, 5, 1154, 578, 2, 10321, 10322, 5, 1536, 769, 2, 10322, 10323, 5, 1532, 767, 2, 10323, 10329, 3, 2, 2, 2, 10324, 10325, 5, 1532, 767, 2, 10325, 10326, 5, 1536, 769, 2, 10326, 10329, 3, 2, 2, 2, 10327, 10329, 3, 2, 2, 2, 10328, 10321, 3, 2, 2, 2, 10328, 10324, 3, 2, 2, 2, 10328, 10327, 3, 2, 2, 2, 10329, 10330, 3, 2, 2, 2, 10330, 10331, 7, 9, 2, 2, 10331, 1531, 3, 2, 2, 2, 10332, 10336, 3, 2, 2, 2, 10333, 10334, 7, 102, 2, 2, 10334, 10336, 5, 1534, 768, 2, 10335, 10332, 3, 2, 2, 2, 10335, 10333, 3, 2, 2, 2, 10336, 1533, 3, 2, 2, 2, 10337, 10342, 5, 1154, 578, 2, 10338, 10339, 7, 8, 2, 2, 10339, 10341, 5, 1154, 578, 2, 10340, 10338, 3, 2, 2, 2, 10341, 10344, 3, 2, 2, 2, 10342, 10340, 3, 2, 2, 2, 10342, 10343, 3, 2, 2, 2, 10343, 1535, 3, 2, 2, 2, 10344, 10342, 3, 2, 2, 2, 10345, 10352, 3, 2, 2, 2, 10346, 10348, 7, 73, 2, 2, 10347, 10349, 7, 339, 2, 2, 10348, 10347, 3, 2, 2, 2, 10348, 10349, 3, 2, 2, 2, 10349, 10350, 3, 2, 2, 2, 10350, 10352, 5, 1552, 777, 2, 10351, 10345, 3, 2, 2, 2, 10351, 10346, 3, 2, 2, 2, 10352, 1537, 3, 2, 2, 2, 10353, 10371, 7, 513, 2, 2, 10354, 10355, 5, 1572, 787, 2, 10355, 10356, 5, 1546, 774, 2, 10356, 10362, 7, 64, 2, 2, 10357, 10363, 5, 954, 478, 2, 10358, 10359, 7, 204, 2, 2, 10359, 10360, 5, 1596, 799, 2, 10360, 10361, 5, 1544, 773, 2, 10361, 10363, 3, 2, 2, 2, 10362, 10357, 3, 2, 2, 2, 10362, 10358, 3, 2, 2, 2, 10363, 10372, 3, 2, 2, 2, 10364, 10369, 5, 1362, 682, 2, 10365, 10366, 7, 4, 2, 2, 10366, 10367, 5, 1542, 772, 2, 10367, 10368, 7, 5, 2, 2, 10368, 10370, 3, 2, 2, 2, 10369, 10365, 3, 2, 2, 2, 10369, 10370, 3, 2, 2, 2, 10370, 10372, 3, 2, 2, 2, 10371, 10354, 3, 2, 2, 2, 10371, 10364, 3, 2, 2, 2, 10372, 10373, 3, 2, 2, 2, 10373, 10374, 7, 9, 2, 2, 10374, 1539, 3, 2, 2, 2, 10375, 10376, 5, 1362, 682, 2, 10376, 10377, 7, 22, 2, 2, 10377, 10378, 5, 1154, 578, 2, 10378, 10381, 3, 2, 2, 2, 10379, 10381, 5, 1154, 578, 2, 10380, 10375, 3, 2, 2, 2, 10380, 10379, 3, 2, 2, 2, 10381, 1541, 3, 2, 2, 2, 10382, 10387, 5, 1540, 771, 2, 10383, 10384, 7, 8, 2, 2, 10384, 10386, 5, 1540, 771, 2, 10385, 10383, 3, 2, 2, 2, 10386, 10389, 3, 2, 2, 2, 10387, 10385, 3, 2, 2, 2, 10387, 10388, 3, 2, 2, 2, 10388, 1543, 3, 2, 2, 2, 10389, 10387, 3, 2, 2, 2, 10390, 10394, 3, 2, 2, 2, 10391, 10392, 7, 102, 2, 2, 10392, 10394, 5, 1270, 636, 2, 10393, 10390, 3, 2, 2, 2, 10393, 10391, 3, 2, 2, 2, 10394, 1545, 3, 2, 2, 2, 10395, 10400, 3, 2, 2, 2, 10396, 10397, 5, 1548, 775, 2, 10397, 10398, 7, 317, 2, 2, 10398, 10400, 3, 2, 2, 2, 10399, 10395, 3, 2, 2, 2, 10399, 10396, 3, 2, 2, 2, 10400, 1547, 3, 2, 2, 2, 10401, 10404, 3, 2, 2, 2, 10402, 10404, 7, 262, 2, 2, 10403, 10401, 3, 2, 2, 2, 10403, 10402, 3, 2, 2, 2, 10404, 1549, 3, 2, 2, 2, 10405, 10406, 7, 63, 2, 2, 10406, 10407, 5, 1556, 779, 2, 10407, 10408, 5, 1554, 778, 2, 10408, 10409, 5, 1572, 787, 2, 10409, 10410, 7, 73, 2, 2, 10410, 10411, 5, 1552, 777, 2, 10411, 10412, 7, 9, 2, 2, 10412, 1551, 3, 2, 2, 2, 10413, 10414, 5, 1270, 636, 2, 10414, 1553, 3, 2, 2, 2, 10415, 10419, 3, 2, 2, 2, 10416, 10419, 7, 66, 2, 2, 10417, 10419, 7, 70, 2, 2, 10418, 10415, 3, 2, 2, 2, 10418, 10416, 3, 2, 2, 2, 10418, 10417, 3, 2, 2, 2, 10419, 1555, 3, 2, 2, 2, 10420, 10438, 3, 2, 2, 2, 10421, 10438, 3, 2, 2, 2, 10422, 10438, 7, 261, 2, 2, 10423, 10438, 7, 286, 2, 2, 10424, 10438, 7, 209, 2, 2, 10425, 10438, 7, 242, 2, 2, 10426, 10427, 7, 132, 2, 2, 10427, 10438, 5, 1154, 578, 2, 10428, 10429, 7, 300, 2, 2, 10429, 10438, 5, 1154, 578, 2, 10430, 10438, 5, 1154, 578, 2, 10431, 10438, 7, 32, 2, 2, 10432, 10435, 9, 65, 2, 2, 10433, 10436, 5, 1154, 578, 2, 10434, 10436, 7, 32, 2, 2, 10435, 10433, 3, 2, 2, 2, 10435, 10434, 3, 2, 2, 2, 10435, 10436, 3, 2, 2, 2, 10436, 10438, 3, 2, 2, 2, 10437, 10420, 3, 2, 2, 2, 10437, 10421, 3, 2, 2, 2, 10437, 10422, 3, 2, 2, 2, 10437, 10423, 3, 2, 2, 2, 10437, 10424, 3, 2, 2, 2, 10437, 10425, 3, 2, 2, 2, 10437, 10426, 3, 2, 2, 2, 10437, 10428, 3, 2, 2, 2, 10437, 10430, 3, 2, 2, 2, 10437, 10431, 3, 2, 2, 2, 10437, 10432, 3, 2, 2, 2, 10438, 1557, 3, 2, 2, 2, 10439, 10440, 7, 258, 2, 2, 10440, 10441, 5, 1556, 779, 2, 10441, 10442, 5, 1572, 787, 2, 10442, 10443, 7, 9, 2, 2, 10443, 1559, 3, 2, 2, 2, 10444, 10445, 7, 159, 2, 2, 10445, 10446, 5, 1572, 787, 2, 10446, 10447, 7, 9, 2, 2, 10447, 1561, 3, 2, 2, 2, 10448, 10449, 7, 80, 2, 2, 10449, 10450, 7, 9, 2, 2, 10450, 1563, 3, 2, 2, 2, 10451, 10452, 7, 163, 2, 2, 10452, 10453, 5, 1568, 785, 2, 10453, 10454, 7, 9, 2, 2, 10454, 1565, 3, 2, 2, 2, 10455, 10456, 7, 312, 2, 2, 10456, 10457, 5, 1568, 785, 2, 10457, 10458, 7, 9, 2, 2, 10458, 1567, 3, 2, 2, 2, 10459, 10461, 7, 35, 2, 2, 10460, 10462, 7, 262, 2, 2, 10461, 10460, 3, 2, 2, 2, 10461, 10462, 3, 2, 2, 2, 10462, 10463, 3, 2, 2, 2, 10463, 10466, 7, 155, 2, 2, 10464, 10466, 3, 2, 2, 2, 10465, 10459, 3, 2, 2, 2, 10465, 10464, 3, 2, 2, 2, 10466, 1569, 3, 2, 2, 2, 10467, 10468, 7, 326, 2, 2, 10468, 10469, 5, 526, 264, 2, 10469, 10470, 7, 96, 2, 2, 10470, 10471, 7, 55, 2, 2, 10471, 10472, 7, 9, 2, 2, 10472, 10480, 3, 2, 2, 2, 10473, 10476, 7, 306, 2, 2, 10474, 10477, 5, 526, 264, 2, 10475, 10477, 7, 32, 2, 2, 10476, 10474, 3, 2, 2, 2, 10476, 10475, 3, 2, 2, 2, 10477, 10478, 3, 2, 2, 2, 10478, 10480, 7, 9, 2, 2, 10479, 10467, 3, 2, 2, 2, 10479, 10473, 3, 2, 2, 2, 10480, 1571, 3, 2, 2, 2, 10481, 10484, 5, 1362, 682, 2, 10482, 10484, 7, 30, 2, 2, 10483, 10481, 3, 2, 2, 2, 10483, 10482, 3, 2, 2, 2, 10484, 1573, 3, 2, 2, 2, 10485, 10489, 3, 2, 2, 2, 10486, 10487, 7, 510, 2, 2, 10487, 10489, 5, 1576, 789, 2, 10488, 10485, 3, 2, 2, 2, 10488, 10486, 3, 2, 2, 2, 10489, 1575, 3, 2, 2, 2, 10490, 10492, 5, 1578, 790, 2, 10491, 10490, 3, 2, 2, 2, 10492, 10493, 3, 2, 2, 2, 10493, 10491, 3, 2, 2, 2, 10493, 10494, 3, 2, 2, 2, 10494, 1577, 3, 2, 2, 2, 10495, 10496, 7, 104, 2, 2, 10496, 10497, 5, 1580, 791, 2, 10497, 10498, 7, 95, 2, 2, 10498, 10499, 5, 1438, 720, 2, 10499, 1579, 3, 2, 2, 2, 10500, 10505, 5, 1582, 792, 2, 10501, 10502, 7, 84, 2, 2, 10502, 10504, 5, 1582, 792, 2, 10503, 10501, 3, 2, 2, 2, 10504, 10507, 3, 2, 2, 2, 10505, 10503, 3, 2, 2, 2, 10505, 10506, 3, 2, 2, 2, 10506, 1581, 3, 2, 2, 2, 10507, 10505, 3, 2, 2, 2, 10508, 10512, 5, 1592, 797, 2, 10509, 10510, 7, 504, 2, 2, 10510, 10512, 5, 1348, 675, 2, 10511, 10508, 3, 2, 2, 2, 10511, 10509, 3, 2, 2, 2, 10512, 1583, 3, 2, 2, 2, 10513, 10516, 3, 2, 2, 2, 10514, 10516, 5, 1402, 702, 2, 10515, 10513, 3, 2, 2, 2, 10515, 10514, 3, 2, 2, 2, 10516, 1585, 3, 2, 2, 2, 10517, 10520, 3, 2, 2, 2, 10518, 10520, 5, 1402, 702, 2, 10519, 10517, 3, 2, 2, 2, 10519, 10518, 3, 2, 2, 2, 10520, 1587, 3, 2, 2, 2, 10521, 10524, 3, 2, 2, 2, 10522, 10524, 5, 1592, 797, 2, 10523, 10521, 3, 2, 2, 2, 10523, 10522, 3, 2, 2, 2, 10524, 1589, 3, 2, 2, 2, 10525, 10526, 7, 104, 2, 2, 10526, 10529, 5, 1600, 801, 2, 10527, 10529, 3, 2, 2, 2, 10528, 10525, 3, 2, 2, 2, 10528, 10527, 3, 2, 2, 2, 10529, 1591, 3, 2, 2, 2, 10530, 10533, 5, 1362, 682, 2, 10531, 10533, 5, 1594, 798, 2, 10532, 10530, 3, 2, 2, 2, 10532, 10531, 3, 2, 2, 2, 10533, 1593, 3, 2, 2, 2, 10534, 10535, 9, 66, 2, 2, 10535, 1595, 3, 2, 2, 2, 10536, 10537, 5, 1318, 660, 2, 10537, 10538, 5, 978, 490, 2, 10538, 10539, 5, 1050, 526, 2, 10539, 10540, 5, 1086, 544, 2, 10540, 10541, 5, 1020, 511, 2, 10541, 10542, 5, 1034, 518, 2, 10542, 10543, 5, 1230, 616, 2, 10543, 1597, 3, 2, 2, 2, 10544, 10545, 5, 1596, 799, 2, 10545, 1599, 3, 2, 2, 2, 10546, 10547, 5, 1596, 799, 2, 10547, 1601, 3, 2, 2, 2, 10548, 10549, 5, 1154, 578, 2, 10549, 1603, 3, 2, 2, 2, 10550, 10551, 5, 1154, 578, 2, 10551, 1605, 3, 2, 2, 2, 10552, 10553, 5, 10, 6, 2, 10553, 10554, 5, 1608, 805, 2, 10554, 1607, 3, 2, 2, 2, 10555, 10556, 7, 73, 2, 2, 10556, 10557, 5, 980, 491, 2, 10557, 10558, 5, 1552, 777, 2, 10558, 10561, 3, 2, 2, 2, 10559, 10561, 3, 2, 2, 2, 10560, 10555, 3, 2, 2, 2, 10560, 10559, 3, 2, 2, 2, 10561, 1609, 3, 2, 2, 2, 724, 1619, 1623, 1750, 1754, 1767, 1772, 1778, 1784, 1799, 1811, 1829, 1834, 1844, 1868, 1875, 1881, 1886, 1895, 1899, 1911, 1942, 1949, 1957, 1962, 1969, 1975, 1992, 1997, 2001, 2014, 2018, 2023, 2028, 2040, 2049, 2062, 2067, 2078, 2089, 2094, 2105, 2116, 2125, 2135, 2150, 2162, 2167, 2174, 2185, 2443, 2450, 2455, 2460, 2465, 2473, 2482, 2489, 2499, 2501, 2506, 2512, 2518, 2520, 2548, 2558, 2571, 2583, 2597, 2602, 2626, 2632, 2637, 2644, 2649, 2687, 2691, 2698, 2702, 2709, 2723, 2730, 2741, 2774, 2784, 2788, 2795, 2802, 2810, 2816, 2820, 2830, 2837, 2848, 2880, 2888, 2893, 2900, 2910, 2920, 2940, 2955, 2980, 2985, 2992, 2999, 3010, 3015, 3022, 3033, 3041, 3052, 3068, 3076, 3080, 3094, 3111, 3116, 3123, 3132, 3135, 3140, 3147, 3158, 3171, 3184, 3202, 3205, 3214, 3229, 3244, 3253, 3260, 3267, 3272, 3302, 3304, 3308, 3316, 3323, 3337, 3341, 3345, 3350, 3356, 3360, 3364, 3377, 3383, 3392, 3401, 3411, 3422, 3532, 3550, 3555, 3559, 3576, 3584, 3591, 3604, 3614, 3648, 3653, 3658, 3662, 3670, 3672, 3730, 3747, 3755, 3778, 3782, 3802, 3839, 3848, 3853, 3858, 3863, 3868, 3921, 3927, 3934, 3944, 3949, 3954, 3972, 3976, 3986, 3992, 3998, 4005, 4010, 4015, 4029, 4057, 4064, 4078, 4093, 4210, 4221, 4227, 4235, 4246, 4255, 4262, 4302, 4308, 4329, 4357, 4361, 4366, 4375, 4379, 4406, 4413, 4428, 4448, 4468, 4561, 4586, 4593, 4609, 4618, 4623, 4629, 4636, 4650, 4799, 4803, 4896, 4901, 4905, 4911, 4979, 4985, 5014, 5031, 5038, 5050, 5110, 5117, 5123, 5129, 5155, 5161, 5167, 5178, 5190, 5219, 5258, 5262, 5266, 5270, 5275, 5282, 5296, 5309, 5317, 5324, 5330, 5334, 5339, 5346, 5360, 5362, 5369, 5373, 5382, 5390, 5399, 5401, 5405, 5414, 5419, 5425, 5430, 5434, 5439, 5457, 5462, 5477, 5486, 5497, 5503, 5542, 5552, 5559, 5570, 5576, 5586, 5598, 5602, 5640, 5654, 5668, 5692, 5699, 5709, 5721, 5726, 5762, 5769, 5784, 5831, 5868, 5879, 5896, 6366, 6370, 6375, 6434, 6438, 6657, 6672, 6683, 6690, 6883, 6893, 6901, 6930, 6946, 6988, 7002, 7024, 7031, 7039, 7043, 7050, 7059, 7068, 7120, 7125, 7137, 7141, 7146, 7151, 7155, 7159, 7164, 7180, 7188, 7193, 7206, 7211, 7218, 7228, 7232, 7243, 7254, 7262, 7269, 7308, 7316, 7320, 7401, 7429, 7434, 7449, 7461, 7468, 7478, 7483, 7487, 7491, 7495, 7499, 7506, 7516, 7521, 7539, 7550, 7557, 7565, 7570, 7583, 7589, 7618, 7625, 7637, 7650, 7665, 7671, 7680, 7696, 7699, 7710, 7715, 7728, 7741, 7752, 7755, 7759, 7765, 7781, 7794, 7804, 7822, 7824, 7832, 7836, 7846, 7856, 7867, 7869, 7873, 7883, 7899, 7901, 7906, 7910, 7916, 7923, 7932, 7947, 7951, 7958, 7961, 7965, 7968, 7981, 7985, 7990, 7998, 8002, 8006, 8017, 8024, 8030, 8034, 8036, 8040, 8046, 8055, 8061, 8063, 8065, 8072, 8076, 8085, 8089, 8099, 8106, 8114, 8138, 8144, 8148, 8153, 8162, 8166, 8169, 8174, 8187, 8193, 8200, 8206, 8227, 8236, 8241, 8247, 8252, 8259, 8264, 8270, 8272, 8276, 8283, 8287, 8292, 8295, 8302, 8306, 8315, 8319, 8327, 8329, 8336, 8341, 8344, 8359, 8371, 8381, 8390, 8395, 8400, 8407, 8410, 8414, 8421, 8445, 8454, 8460, 8464, 8469, 8479, 8486, 8495, 8498, 8507, 8509, 8515, 8519, 8524, 8538, 8540, 8546, 8550, 8559, 8577, 8584, 8588, 8592, 8608, 8615, 8623, 8627, 8634, 8647, 8663, 8669, 8675, 8682, 8687, 8693, 8700, 8708, 8716, 8721, 8725, 8728, 8734, 8739, 8755, 8758, 8760, 8772, 8774, 8778, 8786, 8788, 8793, 8801, 8805, 8814, 8822, 8828, 8831, 8840, 8845, 8852, 8862, 8888, 8899, 8901, 8903, 8911, 8934, 8942, 8952, 8966, 8976, 8980, 8994, 9001, 9008, 9015, 9040, 9069, 9108, 9110, 9138, 9159, 9166, 9179, 9191, 9197, 9206, 9223, 9235, 9244, 9249, 9256, 9266, 9269, 9280, 9286, 9301, 9309, 9318, 9327, 9330, 9335, 9344, 9349, 9363, 9373, 9381, 9395, 9402, 9410, 9418, 9425, 9431, 9440, 9448, 9458, 9469, 9476, 9506, 9515, 9522, 9533, 9543, 9547, 9551, 9556, 9564, 9568, 9572, 9577, 9582, 9587, 9594, 9602, 9605, 9612, 9617, 9624, 9637, 9652, 9666, 9671, 9690, 9695, 9700, 9707, 9714, 9721, 9728, 9734, 9740, 9748, 9757, 9814, 9827, 9850, 9858, 9862, 9874, 9876, 9883, 9892, 9910, 9918, 9927, 9934, 9944, 9950, 9957, 9962, 9968, 9972, 9979, 10009, 10029, 10033, 10049, 10056, 10069, 10077, 10097, 10103, 10115, 10120, 10130, 10162, 10167, 10176, 10181, 10185, 10190, 10206, 10224, 10227, 10233, 10261, 10271, 10278, 10280, 10285, 10296, 10307, 10328, 10335, 10342, 10348, 10351, 10362, 10369, 10371, 10380, 10387, 10393, 10399, 10403, 10418, 10435, 10437, 10461, 10465, 10476, 10479, 10483, 10488, 10493, 10505, 10511, 10515, 10519, 10523, 10528, 10532, 10560] \ No newline at end of file diff --git a/src/lib/pgsql/PostgreSQLParser.js b/src/lib/pgsql/PostgreSQLParser.js new file mode 100644 index 0000000..803c99b --- /dev/null +++ b/src/lib/pgsql/PostgreSQLParser.js @@ -0,0 +1,129402 @@ +// Generated from /Users/salvo/dt-sql-parser2/src/grammar/pgsql/PostgreSQLParser.g4 by ANTLR 4.8 +// jshint ignore: start +var antlr4 = require('antlr4/index'); +var PostgreSQLParserListener = require('./PostgreSQLParserListener').PostgreSQLParserListener; +var PostgreSQLParserVisitor = require('./PostgreSQLParserVisitor').PostgreSQLParserVisitor; + + + +var PostgreSQLParserBase = require('./base/PostgreSQLParserBase').PostgreSQLParserBase; + +var grammarFileName = "PostgreSQLParser.g4"; + + +var serializedATN = ["\u0003\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964", + "\u0003\u022d\u2943\u0004\u0002\t\u0002\u0004\u0003\t\u0003\u0004\u0004", + "\t\u0004\u0004\u0005\t\u0005\u0004\u0006\t\u0006\u0004\u0007\t\u0007", + "\u0004\b\t\b\u0004\t\t\t\u0004\n\t\n\u0004\u000b\t\u000b\u0004\f\t\f", + "\u0004\r\t\r\u0004\u000e\t\u000e\u0004\u000f\t\u000f\u0004\u0010\t\u0010", + "\u0004\u0011\t\u0011\u0004\u0012\t\u0012\u0004\u0013\t\u0013\u0004\u0014", + "\t\u0014\u0004\u0015\t\u0015\u0004\u0016\t\u0016\u0004\u0017\t\u0017", + "\u0004\u0018\t\u0018\u0004\u0019\t\u0019\u0004\u001a\t\u001a\u0004\u001b", + "\t\u001b\u0004\u001c\t\u001c\u0004\u001d\t\u001d\u0004\u001e\t\u001e", + "\u0004\u001f\t\u001f\u0004 \t \u0004!\t!\u0004\"\t\"\u0004#\t#\u0004", + "$\t$\u0004%\t%\u0004&\t&\u0004\'\t\'\u0004(\t(\u0004)\t)\u0004*\t*\u0004", + "+\t+\u0004,\t,\u0004-\t-\u0004.\t.\u0004/\t/\u00040\t0\u00041\t1\u0004", + "2\t2\u00043\t3\u00044\t4\u00045\t5\u00046\t6\u00047\t7\u00048\t8\u0004", + "9\t9\u0004:\t:\u0004;\t;\u0004<\t<\u0004=\t=\u0004>\t>\u0004?\t?\u0004", + "@\t@\u0004A\tA\u0004B\tB\u0004C\tC\u0004D\tD\u0004E\tE\u0004F\tF\u0004", + "G\tG\u0004H\tH\u0004I\tI\u0004J\tJ\u0004K\tK\u0004L\tL\u0004M\tM\u0004", + "N\tN\u0004O\tO\u0004P\tP\u0004Q\tQ\u0004R\tR\u0004S\tS\u0004T\tT\u0004", + "U\tU\u0004V\tV\u0004W\tW\u0004X\tX\u0004Y\tY\u0004Z\tZ\u0004[\t[\u0004", + "\\\t\\\u0004]\t]\u0004^\t^\u0004_\t_\u0004`\t`\u0004a\ta\u0004b\tb\u0004", + "c\tc\u0004d\td\u0004e\te\u0004f\tf\u0004g\tg\u0004h\th\u0004i\ti\u0004", + "j\tj\u0004k\tk\u0004l\tl\u0004m\tm\u0004n\tn\u0004o\to\u0004p\tp\u0004", + "q\tq\u0004r\tr\u0004s\ts\u0004t\tt\u0004u\tu\u0004v\tv\u0004w\tw\u0004", + "x\tx\u0004y\ty\u0004z\tz\u0004{\t{\u0004|\t|\u0004}\t}\u0004~\t~\u0004", + "\u007f\t\u007f\u0004\u0080\t\u0080\u0004\u0081\t\u0081\u0004\u0082\t", + "\u0082\u0004\u0083\t\u0083\u0004\u0084\t\u0084\u0004\u0085\t\u0085\u0004", + "\u0086\t\u0086\u0004\u0087\t\u0087\u0004\u0088\t\u0088\u0004\u0089\t", + "\u0089\u0004\u008a\t\u008a\u0004\u008b\t\u008b\u0004\u008c\t\u008c\u0004", + "\u008d\t\u008d\u0004\u008e\t\u008e\u0004\u008f\t\u008f\u0004\u0090\t", + "\u0090\u0004\u0091\t\u0091\u0004\u0092\t\u0092\u0004\u0093\t\u0093\u0004", + "\u0094\t\u0094\u0004\u0095\t\u0095\u0004\u0096\t\u0096\u0004\u0097\t", + "\u0097\u0004\u0098\t\u0098\u0004\u0099\t\u0099\u0004\u009a\t\u009a\u0004", + "\u009b\t\u009b\u0004\u009c\t\u009c\u0004\u009d\t\u009d\u0004\u009e\t", + "\u009e\u0004\u009f\t\u009f\u0004\u00a0\t\u00a0\u0004\u00a1\t\u00a1\u0004", + "\u00a2\t\u00a2\u0004\u00a3\t\u00a3\u0004\u00a4\t\u00a4\u0004\u00a5\t", + "\u00a5\u0004\u00a6\t\u00a6\u0004\u00a7\t\u00a7\u0004\u00a8\t\u00a8\u0004", + "\u00a9\t\u00a9\u0004\u00aa\t\u00aa\u0004\u00ab\t\u00ab\u0004\u00ac\t", + "\u00ac\u0004\u00ad\t\u00ad\u0004\u00ae\t\u00ae\u0004\u00af\t\u00af\u0004", + "\u00b0\t\u00b0\u0004\u00b1\t\u00b1\u0004\u00b2\t\u00b2\u0004\u00b3\t", + "\u00b3\u0004\u00b4\t\u00b4\u0004\u00b5\t\u00b5\u0004\u00b6\t\u00b6\u0004", + "\u00b7\t\u00b7\u0004\u00b8\t\u00b8\u0004\u00b9\t\u00b9\u0004\u00ba\t", + "\u00ba\u0004\u00bb\t\u00bb\u0004\u00bc\t\u00bc\u0004\u00bd\t\u00bd\u0004", + "\u00be\t\u00be\u0004\u00bf\t\u00bf\u0004\u00c0\t\u00c0\u0004\u00c1\t", + "\u00c1\u0004\u00c2\t\u00c2\u0004\u00c3\t\u00c3\u0004\u00c4\t\u00c4\u0004", + "\u00c5\t\u00c5\u0004\u00c6\t\u00c6\u0004\u00c7\t\u00c7\u0004\u00c8\t", + "\u00c8\u0004\u00c9\t\u00c9\u0004\u00ca\t\u00ca\u0004\u00cb\t\u00cb\u0004", + "\u00cc\t\u00cc\u0004\u00cd\t\u00cd\u0004\u00ce\t\u00ce\u0004\u00cf\t", + "\u00cf\u0004\u00d0\t\u00d0\u0004\u00d1\t\u00d1\u0004\u00d2\t\u00d2\u0004", + "\u00d3\t\u00d3\u0004\u00d4\t\u00d4\u0004\u00d5\t\u00d5\u0004\u00d6\t", + "\u00d6\u0004\u00d7\t\u00d7\u0004\u00d8\t\u00d8\u0004\u00d9\t\u00d9\u0004", + "\u00da\t\u00da\u0004\u00db\t\u00db\u0004\u00dc\t\u00dc\u0004\u00dd\t", + "\u00dd\u0004\u00de\t\u00de\u0004\u00df\t\u00df\u0004\u00e0\t\u00e0\u0004", + "\u00e1\t\u00e1\u0004\u00e2\t\u00e2\u0004\u00e3\t\u00e3\u0004\u00e4\t", + "\u00e4\u0004\u00e5\t\u00e5\u0004\u00e6\t\u00e6\u0004\u00e7\t\u00e7\u0004", + "\u00e8\t\u00e8\u0004\u00e9\t\u00e9\u0004\u00ea\t\u00ea\u0004\u00eb\t", + "\u00eb\u0004\u00ec\t\u00ec\u0004\u00ed\t\u00ed\u0004\u00ee\t\u00ee\u0004", + "\u00ef\t\u00ef\u0004\u00f0\t\u00f0\u0004\u00f1\t\u00f1\u0004\u00f2\t", + "\u00f2\u0004\u00f3\t\u00f3\u0004\u00f4\t\u00f4\u0004\u00f5\t\u00f5\u0004", + "\u00f6\t\u00f6\u0004\u00f7\t\u00f7\u0004\u00f8\t\u00f8\u0004\u00f9\t", + "\u00f9\u0004\u00fa\t\u00fa\u0004\u00fb\t\u00fb\u0004\u00fc\t\u00fc\u0004", + "\u00fd\t\u00fd\u0004\u00fe\t\u00fe\u0004\u00ff\t\u00ff\u0004\u0100\t", + "\u0100\u0004\u0101\t\u0101\u0004\u0102\t\u0102\u0004\u0103\t\u0103\u0004", + "\u0104\t\u0104\u0004\u0105\t\u0105\u0004\u0106\t\u0106\u0004\u0107\t", + "\u0107\u0004\u0108\t\u0108\u0004\u0109\t\u0109\u0004\u010a\t\u010a\u0004", + "\u010b\t\u010b\u0004\u010c\t\u010c\u0004\u010d\t\u010d\u0004\u010e\t", + "\u010e\u0004\u010f\t\u010f\u0004\u0110\t\u0110\u0004\u0111\t\u0111\u0004", + "\u0112\t\u0112\u0004\u0113\t\u0113\u0004\u0114\t\u0114\u0004\u0115\t", + "\u0115\u0004\u0116\t\u0116\u0004\u0117\t\u0117\u0004\u0118\t\u0118\u0004", + "\u0119\t\u0119\u0004\u011a\t\u011a\u0004\u011b\t\u011b\u0004\u011c\t", + "\u011c\u0004\u011d\t\u011d\u0004\u011e\t\u011e\u0004\u011f\t\u011f\u0004", + "\u0120\t\u0120\u0004\u0121\t\u0121\u0004\u0122\t\u0122\u0004\u0123\t", + "\u0123\u0004\u0124\t\u0124\u0004\u0125\t\u0125\u0004\u0126\t\u0126\u0004", + "\u0127\t\u0127\u0004\u0128\t\u0128\u0004\u0129\t\u0129\u0004\u012a\t", + "\u012a\u0004\u012b\t\u012b\u0004\u012c\t\u012c\u0004\u012d\t\u012d\u0004", + "\u012e\t\u012e\u0004\u012f\t\u012f\u0004\u0130\t\u0130\u0004\u0131\t", + "\u0131\u0004\u0132\t\u0132\u0004\u0133\t\u0133\u0004\u0134\t\u0134\u0004", + "\u0135\t\u0135\u0004\u0136\t\u0136\u0004\u0137\t\u0137\u0004\u0138\t", + "\u0138\u0004\u0139\t\u0139\u0004\u013a\t\u013a\u0004\u013b\t\u013b\u0004", + "\u013c\t\u013c\u0004\u013d\t\u013d\u0004\u013e\t\u013e\u0004\u013f\t", + "\u013f\u0004\u0140\t\u0140\u0004\u0141\t\u0141\u0004\u0142\t\u0142\u0004", + "\u0143\t\u0143\u0004\u0144\t\u0144\u0004\u0145\t\u0145\u0004\u0146\t", + "\u0146\u0004\u0147\t\u0147\u0004\u0148\t\u0148\u0004\u0149\t\u0149\u0004", + "\u014a\t\u014a\u0004\u014b\t\u014b\u0004\u014c\t\u014c\u0004\u014d\t", + "\u014d\u0004\u014e\t\u014e\u0004\u014f\t\u014f\u0004\u0150\t\u0150\u0004", + "\u0151\t\u0151\u0004\u0152\t\u0152\u0004\u0153\t\u0153\u0004\u0154\t", + "\u0154\u0004\u0155\t\u0155\u0004\u0156\t\u0156\u0004\u0157\t\u0157\u0004", + "\u0158\t\u0158\u0004\u0159\t\u0159\u0004\u015a\t\u015a\u0004\u015b\t", + "\u015b\u0004\u015c\t\u015c\u0004\u015d\t\u015d\u0004\u015e\t\u015e\u0004", + "\u015f\t\u015f\u0004\u0160\t\u0160\u0004\u0161\t\u0161\u0004\u0162\t", + "\u0162\u0004\u0163\t\u0163\u0004\u0164\t\u0164\u0004\u0165\t\u0165\u0004", + "\u0166\t\u0166\u0004\u0167\t\u0167\u0004\u0168\t\u0168\u0004\u0169\t", + "\u0169\u0004\u016a\t\u016a\u0004\u016b\t\u016b\u0004\u016c\t\u016c\u0004", + "\u016d\t\u016d\u0004\u016e\t\u016e\u0004\u016f\t\u016f\u0004\u0170\t", + "\u0170\u0004\u0171\t\u0171\u0004\u0172\t\u0172\u0004\u0173\t\u0173\u0004", + "\u0174\t\u0174\u0004\u0175\t\u0175\u0004\u0176\t\u0176\u0004\u0177\t", + "\u0177\u0004\u0178\t\u0178\u0004\u0179\t\u0179\u0004\u017a\t\u017a\u0004", + "\u017b\t\u017b\u0004\u017c\t\u017c\u0004\u017d\t\u017d\u0004\u017e\t", + "\u017e\u0004\u017f\t\u017f\u0004\u0180\t\u0180\u0004\u0181\t\u0181\u0004", + "\u0182\t\u0182\u0004\u0183\t\u0183\u0004\u0184\t\u0184\u0004\u0185\t", + "\u0185\u0004\u0186\t\u0186\u0004\u0187\t\u0187\u0004\u0188\t\u0188\u0004", + "\u0189\t\u0189\u0004\u018a\t\u018a\u0004\u018b\t\u018b\u0004\u018c\t", + "\u018c\u0004\u018d\t\u018d\u0004\u018e\t\u018e\u0004\u018f\t\u018f\u0004", + "\u0190\t\u0190\u0004\u0191\t\u0191\u0004\u0192\t\u0192\u0004\u0193\t", + "\u0193\u0004\u0194\t\u0194\u0004\u0195\t\u0195\u0004\u0196\t\u0196\u0004", + "\u0197\t\u0197\u0004\u0198\t\u0198\u0004\u0199\t\u0199\u0004\u019a\t", + "\u019a\u0004\u019b\t\u019b\u0004\u019c\t\u019c\u0004\u019d\t\u019d\u0004", + "\u019e\t\u019e\u0004\u019f\t\u019f\u0004\u01a0\t\u01a0\u0004\u01a1\t", + "\u01a1\u0004\u01a2\t\u01a2\u0004\u01a3\t\u01a3\u0004\u01a4\t\u01a4\u0004", + "\u01a5\t\u01a5\u0004\u01a6\t\u01a6\u0004\u01a7\t\u01a7\u0004\u01a8\t", + "\u01a8\u0004\u01a9\t\u01a9\u0004\u01aa\t\u01aa\u0004\u01ab\t\u01ab\u0004", + "\u01ac\t\u01ac\u0004\u01ad\t\u01ad\u0004\u01ae\t\u01ae\u0004\u01af\t", + "\u01af\u0004\u01b0\t\u01b0\u0004\u01b1\t\u01b1\u0004\u01b2\t\u01b2\u0004", + "\u01b3\t\u01b3\u0004\u01b4\t\u01b4\u0004\u01b5\t\u01b5\u0004\u01b6\t", + "\u01b6\u0004\u01b7\t\u01b7\u0004\u01b8\t\u01b8\u0004\u01b9\t\u01b9\u0004", + "\u01ba\t\u01ba\u0004\u01bb\t\u01bb\u0004\u01bc\t\u01bc\u0004\u01bd\t", + "\u01bd\u0004\u01be\t\u01be\u0004\u01bf\t\u01bf\u0004\u01c0\t\u01c0\u0004", + "\u01c1\t\u01c1\u0004\u01c2\t\u01c2\u0004\u01c3\t\u01c3\u0004\u01c4\t", + "\u01c4\u0004\u01c5\t\u01c5\u0004\u01c6\t\u01c6\u0004\u01c7\t\u01c7\u0004", + "\u01c8\t\u01c8\u0004\u01c9\t\u01c9\u0004\u01ca\t\u01ca\u0004\u01cb\t", + "\u01cb\u0004\u01cc\t\u01cc\u0004\u01cd\t\u01cd\u0004\u01ce\t\u01ce\u0004", + "\u01cf\t\u01cf\u0004\u01d0\t\u01d0\u0004\u01d1\t\u01d1\u0004\u01d2\t", + "\u01d2\u0004\u01d3\t\u01d3\u0004\u01d4\t\u01d4\u0004\u01d5\t\u01d5\u0004", + "\u01d6\t\u01d6\u0004\u01d7\t\u01d7\u0004\u01d8\t\u01d8\u0004\u01d9\t", + "\u01d9\u0004\u01da\t\u01da\u0004\u01db\t\u01db\u0004\u01dc\t\u01dc\u0004", + "\u01dd\t\u01dd\u0004\u01de\t\u01de\u0004\u01df\t\u01df\u0004\u01e0\t", + "\u01e0\u0004\u01e1\t\u01e1\u0004\u01e2\t\u01e2\u0004\u01e3\t\u01e3\u0004", + "\u01e4\t\u01e4\u0004\u01e5\t\u01e5\u0004\u01e6\t\u01e6\u0004\u01e7\t", + "\u01e7\u0004\u01e8\t\u01e8\u0004\u01e9\t\u01e9\u0004\u01ea\t\u01ea\u0004", + "\u01eb\t\u01eb\u0004\u01ec\t\u01ec\u0004\u01ed\t\u01ed\u0004\u01ee\t", + "\u01ee\u0004\u01ef\t\u01ef\u0004\u01f0\t\u01f0\u0004\u01f1\t\u01f1\u0004", + "\u01f2\t\u01f2\u0004\u01f3\t\u01f3\u0004\u01f4\t\u01f4\u0004\u01f5\t", + "\u01f5\u0004\u01f6\t\u01f6\u0004\u01f7\t\u01f7\u0004\u01f8\t\u01f8\u0004", + "\u01f9\t\u01f9\u0004\u01fa\t\u01fa\u0004\u01fb\t\u01fb\u0004\u01fc\t", + "\u01fc\u0004\u01fd\t\u01fd\u0004\u01fe\t\u01fe\u0004\u01ff\t\u01ff\u0004", + "\u0200\t\u0200\u0004\u0201\t\u0201\u0004\u0202\t\u0202\u0004\u0203\t", + "\u0203\u0004\u0204\t\u0204\u0004\u0205\t\u0205\u0004\u0206\t\u0206\u0004", + "\u0207\t\u0207\u0004\u0208\t\u0208\u0004\u0209\t\u0209\u0004\u020a\t", + "\u020a\u0004\u020b\t\u020b\u0004\u020c\t\u020c\u0004\u020d\t\u020d\u0004", + "\u020e\t\u020e\u0004\u020f\t\u020f\u0004\u0210\t\u0210\u0004\u0211\t", + "\u0211\u0004\u0212\t\u0212\u0004\u0213\t\u0213\u0004\u0214\t\u0214\u0004", + "\u0215\t\u0215\u0004\u0216\t\u0216\u0004\u0217\t\u0217\u0004\u0218\t", + "\u0218\u0004\u0219\t\u0219\u0004\u021a\t\u021a\u0004\u021b\t\u021b\u0004", + "\u021c\t\u021c\u0004\u021d\t\u021d\u0004\u021e\t\u021e\u0004\u021f\t", + "\u021f\u0004\u0220\t\u0220\u0004\u0221\t\u0221\u0004\u0222\t\u0222\u0004", + "\u0223\t\u0223\u0004\u0224\t\u0224\u0004\u0225\t\u0225\u0004\u0226\t", + "\u0226\u0004\u0227\t\u0227\u0004\u0228\t\u0228\u0004\u0229\t\u0229\u0004", + "\u022a\t\u022a\u0004\u022b\t\u022b\u0004\u022c\t\u022c\u0004\u022d\t", + "\u022d\u0004\u022e\t\u022e\u0004\u022f\t\u022f\u0004\u0230\t\u0230\u0004", + "\u0231\t\u0231\u0004\u0232\t\u0232\u0004\u0233\t\u0233\u0004\u0234\t", + "\u0234\u0004\u0235\t\u0235\u0004\u0236\t\u0236\u0004\u0237\t\u0237\u0004", + "\u0238\t\u0238\u0004\u0239\t\u0239\u0004\u023a\t\u023a\u0004\u023b\t", + "\u023b\u0004\u023c\t\u023c\u0004\u023d\t\u023d\u0004\u023e\t\u023e\u0004", + "\u023f\t\u023f\u0004\u0240\t\u0240\u0004\u0241\t\u0241\u0004\u0242\t", + "\u0242\u0004\u0243\t\u0243\u0004\u0244\t\u0244\u0004\u0245\t\u0245\u0004", + "\u0246\t\u0246\u0004\u0247\t\u0247\u0004\u0248\t\u0248\u0004\u0249\t", + "\u0249\u0004\u024a\t\u024a\u0004\u024b\t\u024b\u0004\u024c\t\u024c\u0004", + "\u024d\t\u024d\u0004\u024e\t\u024e\u0004\u024f\t\u024f\u0004\u0250\t", + "\u0250\u0004\u0251\t\u0251\u0004\u0252\t\u0252\u0004\u0253\t\u0253\u0004", + "\u0254\t\u0254\u0004\u0255\t\u0255\u0004\u0256\t\u0256\u0004\u0257\t", + "\u0257\u0004\u0258\t\u0258\u0004\u0259\t\u0259\u0004\u025a\t\u025a\u0004", + "\u025b\t\u025b\u0004\u025c\t\u025c\u0004\u025d\t\u025d\u0004\u025e\t", + "\u025e\u0004\u025f\t\u025f\u0004\u0260\t\u0260\u0004\u0261\t\u0261\u0004", + "\u0262\t\u0262\u0004\u0263\t\u0263\u0004\u0264\t\u0264\u0004\u0265\t", + "\u0265\u0004\u0266\t\u0266\u0004\u0267\t\u0267\u0004\u0268\t\u0268\u0004", + "\u0269\t\u0269\u0004\u026a\t\u026a\u0004\u026b\t\u026b\u0004\u026c\t", + "\u026c\u0004\u026d\t\u026d\u0004\u026e\t\u026e\u0004\u026f\t\u026f\u0004", + "\u0270\t\u0270\u0004\u0271\t\u0271\u0004\u0272\t\u0272\u0004\u0273\t", + "\u0273\u0004\u0274\t\u0274\u0004\u0275\t\u0275\u0004\u0276\t\u0276\u0004", + "\u0277\t\u0277\u0004\u0278\t\u0278\u0004\u0279\t\u0279\u0004\u027a\t", + "\u027a\u0004\u027b\t\u027b\u0004\u027c\t\u027c\u0004\u027d\t\u027d\u0004", + "\u027e\t\u027e\u0004\u027f\t\u027f\u0004\u0280\t\u0280\u0004\u0281\t", + "\u0281\u0004\u0282\t\u0282\u0004\u0283\t\u0283\u0004\u0284\t\u0284\u0004", + "\u0285\t\u0285\u0004\u0286\t\u0286\u0004\u0287\t\u0287\u0004\u0288\t", + "\u0288\u0004\u0289\t\u0289\u0004\u028a\t\u028a\u0004\u028b\t\u028b\u0004", + "\u028c\t\u028c\u0004\u028d\t\u028d\u0004\u028e\t\u028e\u0004\u028f\t", + "\u028f\u0004\u0290\t\u0290\u0004\u0291\t\u0291\u0004\u0292\t\u0292\u0004", + "\u0293\t\u0293\u0004\u0294\t\u0294\u0004\u0295\t\u0295\u0004\u0296\t", + "\u0296\u0004\u0297\t\u0297\u0004\u0298\t\u0298\u0004\u0299\t\u0299\u0004", + "\u029a\t\u029a\u0004\u029b\t\u029b\u0004\u029c\t\u029c\u0004\u029d\t", + "\u029d\u0004\u029e\t\u029e\u0004\u029f\t\u029f\u0004\u02a0\t\u02a0\u0004", + "\u02a1\t\u02a1\u0004\u02a2\t\u02a2\u0004\u02a3\t\u02a3\u0004\u02a4\t", + "\u02a4\u0004\u02a5\t\u02a5\u0004\u02a6\t\u02a6\u0004\u02a7\t\u02a7\u0004", + "\u02a8\t\u02a8\u0004\u02a9\t\u02a9\u0004\u02aa\t\u02aa\u0004\u02ab\t", + "\u02ab\u0004\u02ac\t\u02ac\u0004\u02ad\t\u02ad\u0004\u02ae\t\u02ae\u0004", + "\u02af\t\u02af\u0004\u02b0\t\u02b0\u0004\u02b1\t\u02b1\u0004\u02b2\t", + "\u02b2\u0004\u02b3\t\u02b3\u0004\u02b4\t\u02b4\u0004\u02b5\t\u02b5\u0004", + "\u02b6\t\u02b6\u0004\u02b7\t\u02b7\u0004\u02b8\t\u02b8\u0004\u02b9\t", + "\u02b9\u0004\u02ba\t\u02ba\u0004\u02bb\t\u02bb\u0004\u02bc\t\u02bc\u0004", + "\u02bd\t\u02bd\u0004\u02be\t\u02be\u0004\u02bf\t\u02bf\u0004\u02c0\t", + "\u02c0\u0004\u02c1\t\u02c1\u0004\u02c2\t\u02c2\u0004\u02c3\t\u02c3\u0004", + "\u02c4\t\u02c4\u0004\u02c5\t\u02c5\u0004\u02c6\t\u02c6\u0004\u02c7\t", + "\u02c7\u0004\u02c8\t\u02c8\u0004\u02c9\t\u02c9\u0004\u02ca\t\u02ca\u0004", + "\u02cb\t\u02cb\u0004\u02cc\t\u02cc\u0004\u02cd\t\u02cd\u0004\u02ce\t", + "\u02ce\u0004\u02cf\t\u02cf\u0004\u02d0\t\u02d0\u0004\u02d1\t\u02d1\u0004", + "\u02d2\t\u02d2\u0004\u02d3\t\u02d3\u0004\u02d4\t\u02d4\u0004\u02d5\t", + "\u02d5\u0004\u02d6\t\u02d6\u0004\u02d7\t\u02d7\u0004\u02d8\t\u02d8\u0004", + "\u02d9\t\u02d9\u0004\u02da\t\u02da\u0004\u02db\t\u02db\u0004\u02dc\t", + "\u02dc\u0004\u02dd\t\u02dd\u0004\u02de\t\u02de\u0004\u02df\t\u02df\u0004", + "\u02e0\t\u02e0\u0004\u02e1\t\u02e1\u0004\u02e2\t\u02e2\u0004\u02e3\t", + "\u02e3\u0004\u02e4\t\u02e4\u0004\u02e5\t\u02e5\u0004\u02e6\t\u02e6\u0004", + "\u02e7\t\u02e7\u0004\u02e8\t\u02e8\u0004\u02e9\t\u02e9\u0004\u02ea\t", + "\u02ea\u0004\u02eb\t\u02eb\u0004\u02ec\t\u02ec\u0004\u02ed\t\u02ed\u0004", + "\u02ee\t\u02ee\u0004\u02ef\t\u02ef\u0004\u02f0\t\u02f0\u0004\u02f1\t", + "\u02f1\u0004\u02f2\t\u02f2\u0004\u02f3\t\u02f3\u0004\u02f4\t\u02f4\u0004", + "\u02f5\t\u02f5\u0004\u02f6\t\u02f6\u0004\u02f7\t\u02f7\u0004\u02f8\t", + "\u02f8\u0004\u02f9\t\u02f9\u0004\u02fa\t\u02fa\u0004\u02fb\t\u02fb\u0004", + "\u02fc\t\u02fc\u0004\u02fd\t\u02fd\u0004\u02fe\t\u02fe\u0004\u02ff\t", + "\u02ff\u0004\u0300\t\u0300\u0004\u0301\t\u0301\u0004\u0302\t\u0302\u0004", + "\u0303\t\u0303\u0004\u0304\t\u0304\u0004\u0305\t\u0305\u0004\u0306\t", + "\u0306\u0004\u0307\t\u0307\u0004\u0308\t\u0308\u0004\u0309\t\u0309\u0004", + "\u030a\t\u030a\u0004\u030b\t\u030b\u0004\u030c\t\u030c\u0004\u030d\t", + "\u030d\u0004\u030e\t\u030e\u0004\u030f\t\u030f\u0004\u0310\t\u0310\u0004", + "\u0311\t\u0311\u0004\u0312\t\u0312\u0004\u0313\t\u0313\u0004\u0314\t", + "\u0314\u0004\u0315\t\u0315\u0004\u0316\t\u0316\u0004\u0317\t\u0317\u0004", + "\u0318\t\u0318\u0004\u0319\t\u0319\u0004\u031a\t\u031a\u0004\u031b\t", + "\u031b\u0004\u031c\t\u031c\u0004\u031d\t\u031d\u0004\u031e\t\u031e\u0004", + "\u031f\t\u031f\u0004\u0320\t\u0320\u0004\u0321\t\u0321\u0004\u0322\t", + "\u0322\u0004\u0323\t\u0323\u0004\u0324\t\u0324\u0004\u0325\t\u0325\u0003", + "\u0002\u0003\u0002\u0003\u0002\u0003\u0003\u0003\u0003\u0003\u0004\u0003", + "\u0004\u0003\u0005\u0003\u0005\u0005\u0005\u0654\n\u0005\u0007\u0005", + "\u0656\n\u0005\f\u0005\u000e\u0005\u0659\u000b\u0005\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003\u0006\u0003", + "\u0006\u0003\u0006\u0003\u0006\u0005\u0006\u06d7\n\u0006\u0003\u0007", + "\u0003\u0007\u0005\u0007\u06db\n\u0007\u0003\b\u0003\b\u0003\b\u0003", + "\t\u0003\t\u0003\t\u0003\t\u0003\t\u0003\t\u0003\n\u0003\n\u0005\n\u06e8", + "\n\n\u0003\u000b\u0007\u000b\u06eb\n\u000b\f\u000b\u000e\u000b\u06ee", + "\u000b\u000b\u0003\f\u0007\f\u06f1\n\f\f\f\u000e\f\u06f4\u000b\f\u0003", + "\r\u0003\r\u0003\r\u0005\r\u06f9\n\r\u0003\r\u0003\r\u0003\r\u0003\r", + "\u0003\r\u0003\r\u0003\r\u0003\r\u0003\r\u0003\r\u0003\r\u0003\r\u0003", + "\r\u0005\r\u0708\n\r\u0003\u000e\u0003\u000e\u0003\u000e\u0003\u000e", + "\u0003\u000e\u0003\u000e\u0003\u000e\u0003\u000e\u0003\u000e\u0003\u000e", + "\u0005\u000e\u0714\n\u000e\u0003\u000f\u0003\u000f\u0003\u000f\u0003", + "\u000f\u0003\u000f\u0003\u000f\u0003\u0010\u0003\u0010\u0003\u0010\u0003", + "\u0010\u0003\u0010\u0003\u0010\u0003\u0011\u0003\u0011\u0003\u0011\u0003", + "\u0011\u0005\u0011\u0726\n\u0011\u0003\u0012\u0003\u0012\u0003\u0012", + "\u0005\u0012\u072b\n\u0012\u0003\u0012\u0003\u0012\u0003\u0012\u0003", + "\u0012\u0003\u0013\u0003\u0013\u0003\u0013\u0003\u0013\u0005\u0013\u0735", + "\n\u0013\u0003\u0013\u0003\u0013\u0003\u0014\u0003\u0014\u0003\u0014", + "\u0003\u0014\u0003\u0014\u0003\u0014\u0003\u0015\u0003\u0015\u0003\u0015", + "\u0003\u0015\u0003\u0015\u0003\u0015\u0003\u0015\u0003\u0016\u0003\u0016", + "\u0003\u0017\u0003\u0017\u0003\u0017\u0003\u0017\u0003\u0017\u0005\u0017", + "\u074d\n\u0017\u0003\u0017\u0003\u0017\u0003\u0017\u0003\u0017\u0003", + "\u0017\u0005\u0017\u0754\n\u0017\u0003\u0017\u0003\u0017\u0003\u0018", + "\u0003\u0018\u0005\u0018\u075a\n\u0018\u0003\u0019\u0007\u0019\u075d", + "\n\u0019\f\u0019\u000e\u0019\u0760\u000b\u0019\u0003\u001a\u0003\u001a", + "\u0003\u001a\u0003\u001a\u0003\u001a\u0003\u001a\u0005\u001a\u0768\n", + "\u001a\u0003\u001b\u0003\u001b\u0005\u001b\u076c\n\u001b\u0003\u001b", + "\u0003\u001b\u0003\u001c\u0003\u001c\u0003\u001c\u0003\u001c\u0003\u001c", + "\u0003\u001c\u0003\u001c\u0003\u001c\u0005\u001c\u0778\n\u001c\u0003", + "\u001d\u0003\u001d\u0003\u001d\u0003\u001d\u0003\u001e\u0003\u001e\u0003", + "\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003", + "\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003", + "\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003", + "\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0003\u001e\u0005\u001e\u0797", + "\n\u001e\u0003\u001f\u0003\u001f\u0003\u001f\u0007\u001f\u079c\n\u001f", + "\f\u001f\u000e\u001f\u079f\u000b\u001f\u0003 \u0003 \u0003 \u0007 \u07a4", + "\n \f \u000e \u07a7\u000b \u0003!\u0003!\u0005!\u07ab\n!\u0003\"\u0003", + "\"\u0003\"\u0003\"\u0003\"\u0005\"\u07b2\n\"\u0003#\u0003#\u0003#\u0003", + "#\u0005#\u07b8\n#\u0003$\u0003$\u0003$\u0003$\u0003$\u0003$\u0003$\u0003", + "$\u0003$\u0003$\u0003$\u0003$\u0003$\u0003$\u0003$\u0005$\u07c9\n$\u0003", + "%\u0003%\u0003%\u0005%\u07ce\n%\u0003&\u0003&\u0005&\u07d2\n&\u0003", + "\'\u0003\'\u0003\'\u0003(\u0003(\u0003(\u0003(\u0003(\u0003(\u0003(", + "\u0003(\u0005(\u07df\n(\u0003)\u0003)\u0005)\u07e3\n)\u0003*\u0003*", + "\u0003*\u0005*\u07e8\n*\u0003+\u0003+\u0003+\u0005+\u07ed\n+\u0003,", + "\u0003,\u0003,\u0003,\u0003,\u0003,\u0003,\u0003,\u0003,\u0003,\u0005", + ",\u07f9\n,\u0003-\u0003-\u0003-\u0003-\u0003-\u0003.\u0003.\u0005.\u0802", + "\n.\u0003/\u0003/\u00030\u00030\u00031\u00031\u00031\u00032\u00032\u0003", + "2\u00032\u00052\u080f\n2\u00032\u00032\u00032\u00052\u0814\n2\u0003", + "2\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00052\u081f", + "\n2\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u0005", + "2\u082a\n2\u00032\u00032\u00032\u00052\u082f\n2\u00032\u00032\u0003", + "2\u00032\u00032\u00032\u00032\u00032\u00032\u00052\u083a\n2\u00032\u0003", + "2\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00052\u0845\n2\u0003", + "2\u00032\u00032\u00032\u00032\u00032\u00032\u00052\u084e\n2\u00032\u0003", + "2\u00032\u00032\u00032\u00032\u00032\u00032\u00052\u0858\n2\u00032\u0003", + "2\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u00032\u0003", + "2\u00032\u00052\u0867\n2\u00032\u00032\u00032\u00032\u00032\u00032\u0003", + "2\u00032\u00032\u00032\u00052\u0873\n2\u00032\u00032\u00032\u00052\u0878", + "\n2\u00033\u00033\u00033\u00073\u087d\n3\f3\u000e3\u0880\u000b3\u0003", + "4\u00034\u00034\u00034\u00034\u00034\u00034\u00034\u00054\u088a\n4\u0003", + "5\u00035\u00035\u00035\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u00036\u0003", + "6\u00036\u00036\u00036\u00036\u00036\u00056\u098c\n6\u00037\u00037\u0003", + "7\u00037\u00037\u00057\u0993\n7\u00038\u00038\u00038\u00058\u0998\n", + "8\u00039\u00039\u00039\u00059\u099d\n9\u0003:\u0003:\u0003:\u0005:\u09a2", + "\n:\u0003;\u0003;\u0003;\u0003;\u0003;\u0003;\u0005;\u09aa\n;\u0003", + "<\u0003<\u0003<\u0003<\u0003=\u0003=\u0003=\u0005=\u09b3\n=\u0003>\u0003", + ">\u0003>\u0007>\u09b8\n>\f>\u000e>\u09bb\u000b>\u0003?\u0003?\u0003", + "?\u0003?\u0003?\u0003?\u0003?\u0005?\u09c4\n?\u0005?\u09c6\n?\u0003", + "@\u0006@\u09c9\n@\r@\u000e@\u09ca\u0003A\u0003A\u0003A\u0003A\u0005", + "A\u09d1\nA\u0003A\u0003A\u0003A\u0003A\u0005A\u09d7\nA\u0005A\u09d9", + "\nA\u0003B\u0003B\u0003B\u0003B\u0003B\u0003B\u0003B\u0003B\u0003B\u0003", + "B\u0003B\u0003B\u0003B\u0003B\u0003B\u0003B\u0003B\u0003B\u0003B\u0003", + "B\u0003B\u0003B\u0003B\u0003B\u0003B\u0003B\u0005B\u09f5\nB\u0003C\u0003", + "C\u0003C\u0003D\u0003D\u0003D\u0007D\u09fd\nD\fD\u000eD\u0a00\u000b", + "D\u0003E\u0003E\u0003E\u0003E\u0003E\u0003F\u0003F\u0003F\u0007F\u0a0a", + "\nF\fF\u000eF\u0a0d\u000bF\u0003G\u0003G\u0003G\u0003G\u0003G\u0003", + "G\u0003G\u0003G\u0003G\u0005G\u0a18\nG\u0003G\u0003G\u0003G\u0003G\u0003", + "G\u0003G\u0003G\u0003G\u0003G\u0003G\u0003G\u0003G\u0005G\u0a26\nG\u0003", + "H\u0003H\u0003H\u0005H\u0a2b\nH\u0003I\u0003I\u0003I\u0003I\u0003I\u0003", + "I\u0003I\u0003I\u0003I\u0003I\u0003I\u0003I\u0003I\u0003I\u0003I\u0003", + "I\u0003I\u0003I\u0003I\u0003I\u0003I\u0003I\u0005I\u0a43\nI\u0003J\u0003", + "J\u0003K\u0003K\u0005K\u0a49\nK\u0003L\u0003L\u0003L\u0005L\u0a4e\n", + "L\u0003M\u0003M\u0003M\u0003M\u0003M\u0005M\u0a55\nM\u0003N\u0007N\u0a58", + "\nN\fN\u000eN\u0a5b\u000bN\u0003O\u0003O\u0003O\u0003O\u0003O\u0003", + "O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003", + "O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003", + "O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0003O\u0005", + "O\u0a80\nO\u0003P\u0003P\u0005P\u0a84\nP\u0003Q\u0003Q\u0003Q\u0003", + "Q\u0003Q\u0005Q\u0a8b\nQ\u0003R\u0003R\u0005R\u0a8f\nR\u0003S\u0003", + "S\u0003S\u0007S\u0a94\nS\fS\u000eS\u0a97\u000bS\u0003T\u0003T\u0003", + "T\u0003U\u0003U\u0003U\u0003U\u0003U\u0003U\u0003U\u0003U\u0005U\u0aa4", + "\nU\u0003V\u0003V\u0003V\u0007V\u0aa9\nV\fV\u000eV\u0aac\u000bV\u0003", + "W\u0003W\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0005X\u0ab6\nX\u0003", + "X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003", + "X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003", + "X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003X\u0003", + "X\u0005X\u0ad7\nX\u0003Y\u0003Y\u0003Y\u0003Y\u0003Y\u0003Y\u0003Y\u0003", + "Y\u0005Y\u0ae1\nY\u0003Z\u0003Z\u0005Z\u0ae5\nZ\u0003[\u0003[\u0003", + "[\u0003[\u0003[\u0005[\u0aec\n[\u0003\\\u0003\\\u0003\\\u0007\\\u0af1", + "\n\\\f\\\u000e\\\u0af4\u000b\\\u0003]\u0003]\u0003]\u0007]\u0af9\n]", + "\f]\u000e]\u0afc\u000b]\u0003^\u0003^\u0003^\u0005^\u0b01\n^\u0003_", + "\u0003_\u0005_\u0b05\n_\u0003`\u0003`\u0003`\u0003`\u0003`\u0003a\u0003", + "a\u0003a\u0005a\u0b0f\na\u0003a\u0003a\u0003b\u0007b\u0b14\nb\fb\u000e", + "b\u0b17\u000bb\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003c\u0003", + "c\u0005c\u0b21\nc\u0003d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003", + "d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003", + "d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003d\u0003", + "d\u0003d\u0003d\u0005d\u0b41\nd\u0003d\u0003d\u0003d\u0003d\u0003d\u0003", + "d\u0005d\u0b49\nd\u0003e\u0003e\u0003e\u0005e\u0b4e\ne\u0003f\u0003", + "f\u0003f\u0003f\u0003f\u0005f\u0b55\nf\u0003g\u0003g\u0003g\u0003g\u0003", + "h\u0003h\u0007h\u0b5d\nh\fh\u000eh\u0b60\u000bh\u0003i\u0003i\u0003", + "j\u0003j\u0003j\u0003j\u0003j\u0005j\u0b69\nj\u0003k\u0003k\u0003k\u0003", + "k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003", + "k\u0003k\u0003k\u0003k\u0003k\u0005k\u0b7d\nk\u0003k\u0003k\u0003k\u0003", + "k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0005", + "k\u0b8c\nk\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003", + "k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003k\u0003", + "k\u0003k\u0003k\u0003k\u0003k\u0005k\u0ba5\nk\u0003l\u0003l\u0003l\u0005", + "l\u0baa\nl\u0003m\u0003m\u0003m\u0003m\u0003m\u0005m\u0bb1\nm\u0003", + "n\u0003n\u0003n\u0007n\u0bb6\nn\fn\u000en\u0bb9\u000bn\u0003o\u0003", + "o\u0003p\u0003p\u0003p\u0003p\u0003p\u0003p\u0005p\u0bc3\np\u0003q\u0003", + "q\u0003q\u0005q\u0bc8\nq\u0003r\u0003r\u0003r\u0007r\u0bcd\nr\fr\u000e", + "r\u0bd0\u000br\u0003s\u0003s\u0003s\u0003s\u0003s\u0003s\u0003s\u0003", + "s\u0005s\u0bda\ns\u0003t\u0003t\u0003t\u0003t\u0003t\u0003t\u0005t\u0be2", + "\nt\u0003u\u0003u\u0003u\u0003u\u0003u\u0003u\u0003u\u0003u\u0003u\u0005", + "u\u0bed\nu\u0003v\u0003v\u0003v\u0003v\u0003w\u0003w\u0003w\u0003w\u0003", + "x\u0003x\u0003x\u0003x\u0003x\u0003x\u0005x\u0bfd\nx\u0003y\u0003y\u0003", + "y\u0003y\u0003y\u0003y\u0005y\u0c05\ny\u0003z\u0003z\u0005z\u0c09\n", + "z\u0003{\u0003{\u0003{\u0003{\u0003{\u0003{\u0003{\u0003|\u0003|\u0003", + "|\u0007|\u0c15\n|\f|\u000e|\u0c18\u000b|\u0003}\u0003}\u0003}\u0003", + "}\u0003}\u0003}\u0003}\u0003}\u0003}\u0003}\u0003}\u0003}\u0003}\u0003", + "}\u0005}\u0c28\n}\u0003~\u0003~\u0003~\u0005~\u0c2d\n~\u0003\u007f\u0003", + "\u007f\u0003\u007f\u0003\u007f\u0003\u007f\u0005\u007f\u0c34\n\u007f", + "\u0003\u0080\u0003\u0080\u0003\u0080\u0003\u0080\u0003\u0080\u0003\u0080", + "\u0003\u0080\u0005\u0080\u0c3d\n\u0080\u0003\u0080\u0005\u0080\u0c40", + "\n\u0080\u0003\u0081\u0003\u0081\u0003\u0081\u0005\u0081\u0c45\n\u0081", + "\u0003\u0082\u0003\u0082\u0003\u0082\u0003\u0082\u0003\u0082\u0005\u0082", + "\u0c4c\n\u0082\u0003\u0083\u0003\u0083\u0003\u0083\u0003\u0083\u0003", + "\u0084\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0084\u0005\u0084\u0c57", + "\n\u0084\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0084\u0003\u0084", + "\u0003\u0084\u0003\u0084\u0003\u0085\u0003\u0085\u0003\u0085\u0003\u0085", + "\u0005\u0085\u0c64\n\u0085\u0003\u0085\u0003\u0085\u0003\u0085\u0003", + "\u0085\u0003\u0085\u0003\u0086\u0003\u0086\u0003\u0086\u0003\u0086\u0003", + "\u0086\u0003\u0086\u0005\u0086\u0c71\n\u0086\u0003\u0086\u0003\u0086", + "\u0003\u0086\u0003\u0086\u0003\u0086\u0003\u0087\u0003\u0087\u0003\u0087", + "\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0087\u0003\u0088\u0003\u0088", + "\u0003\u0088\u0003\u0088\u0005\u0088\u0c83\n\u0088\u0003\u0088\u0005", + "\u0088\u0c86\n\u0088\u0003\u0089\u0003\u0089\u0003\u0089\u0003\u0089", + "\u0003\u0089\u0003\u0089\u0003\u0089\u0005\u0089\u0c8f\n\u0089\u0003", + "\u0089\u0003\u0089\u0003\u0089\u0003\u0089\u0003\u0089\u0003\u008a\u0003", + "\u008a\u0003\u008a\u0003\u008a\u0003\u008a\u0003\u008a\u0003\u008b\u0003", + "\u008b\u0005\u008b\u0c9e\n\u008b\u0003\u008c\u0003\u008c\u0003\u008c", + "\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008c\u0003\u008d\u0003\u008d", + "\u0003\u008d\u0003\u008d\u0003\u008d\u0003\u008d\u0005\u008d\u0cad\n", + "\u008d\u0003\u008d\u0003\u008d\u0003\u008d\u0003\u008e\u0003\u008e\u0003", + "\u008e\u0003\u008e\u0005\u008e\u0cb6\n\u008e\u0003\u008e\u0003\u008e", + "\u0003\u008e\u0003\u008f\u0003\u008f\u0005\u008f\u0cbd\n\u008f\u0003", + "\u0090\u0003\u0090\u0003\u0090\u0003\u0090\u0003\u0090\u0005\u0090\u0cc4", + "\n\u0090\u0003\u0091\u0006\u0091\u0cc7\n\u0091\r\u0091\u000e\u0091\u0cc8", + "\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092", + "\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092", + "\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092", + "\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092", + "\u0003\u0092\u0003\u0092\u0003\u0092\u0003\u0092\u0005\u0092\u0ce7\n", + "\u0092\u0005\u0092\u0ce9\n\u0092\u0003\u0093\u0003\u0093\u0005\u0093", + "\u0ced\n\u0093\u0003\u0094\u0003\u0094\u0003\u0094\u0003\u0094\u0003", + "\u0094\u0003\u0094\u0005\u0094\u0cf5\n\u0094\u0003\u0095\u0003\u0095", + "\u0003\u0095\u0007\u0095\u0cfa\n\u0095\f\u0095\u000e\u0095\u0cfd\u000b", + "\u0095\u0003\u0096\u0003\u0096\u0003\u0096\u0003\u0096\u0003\u0096\u0003", + "\u0096\u0003\u0096\u0003\u0096\u0003\u0096\u0003\u0096\u0003\u0096\u0005", + "\u0096\u0d0a\n\u0096\u0003\u0097\u0003\u0097\u0005\u0097\u0d0e\n\u0097", + "\u0003\u0098\u0003\u0098\u0005\u0098\u0d12\n\u0098\u0003\u0099\u0003", + "\u0099\u0003\u0099\u0005\u0099\u0d17\n\u0099\u0003\u009a\u0003\u009a", + "\u0003\u009a\u0003\u009a\u0005\u009a\u0d1d\n\u009a\u0003\u009b\u0003", + "\u009b\u0005\u009b\u0d21\n\u009b\u0003\u009c\u0003\u009c\u0005\u009c", + "\u0d25\n\u009c\u0003\u009d\u0003\u009d\u0003\u009d\u0003\u009d\u0003", + "\u009d\u0003\u009d\u0003\u009d\u0003\u009d\u0003\u009e\u0003\u009e\u0003", + "\u009e\u0005\u009e\u0d32\n\u009e\u0003\u009f\u0003\u009f\u0003\u009f", + "\u0003\u009f\u0005\u009f\u0d38\n\u009f\u0003\u009f\u0003\u009f\u0003", + "\u00a0\u0003\u00a0\u0003\u00a0\u0003\u00a0\u0003\u00a0\u0005\u00a0\u0d41", + "\n\u00a0\u0003\u00a0\u0003\u00a0\u0003\u00a0\u0003\u00a0\u0003\u00a1", + "\u0007\u00a1\u0d48\n\u00a1\f\u00a1\u000e\u00a1\u0d4b\u000b\u00a1\u0003", + "\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003\u00a2\u0003", + "\u00a2\u0005\u00a2\u0d54\n\u00a2\u0003\u00a3\u0003\u00a3\u0003\u00a3", + "\u0003\u00a3\u0003\u00a3\u0003\u00a3\u0003\u00a4\u0007\u00a4\u0d5d\n", + "\u00a4\f\u00a4\u000e\u00a4\u0d60\u000b\u00a4\u0003\u00a5\u0003\u00a5", + "\u0003\u00a5\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0003\u00a6", + "\u0003\u00a6\u0003\u00a6\u0003\u00a6\u0005\u00a6\u0dcd\n\u00a6\u0003", + "\u00a7\u0003\u00a7\u0003\u00a7\u0003\u00a7\u0003\u00a7\u0003\u00a7\u0003", + "\u00a7\u0003\u00a7\u0003\u00a8\u0003\u00a8\u0003\u00a8\u0003\u00a8\u0003", + "\u00a8\u0003\u00a8\u0003\u00a8\u0003\u00a8\u0005\u00a8\u0ddf\n\u00a8", + "\u0003\u00a9\u0006\u00a9\u0de2\n\u00a9\r\u00a9\u000e\u00a9\u0de3\u0003", + "\u00aa\u0003\u00aa\u0005\u00aa\u0de8\n\u00aa\u0003\u00ab\u0003\u00ab", + "\u0003\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ab", + "\u0003\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ab\u0003\u00ab", + "\u0003\u00ab\u0005\u00ab\u0df9\n\u00ab\u0003\u00ac\u0003\u00ac\u0003", + "\u00ac\u0003\u00ac\u0003\u00ac\u0003\u00ac\u0005\u00ac\u0e01\n\u00ac", + "\u0003\u00ad\u0003\u00ad\u0003\u00ad\u0007\u00ad\u0e06\n\u00ad\f\u00ad", + "\u000e\u00ad\u0e09\u000b\u00ad\u0003\u00ae\u0003\u00ae\u0003\u00ae\u0003", + "\u00ae\u0003\u00ae\u0003\u00af\u0003\u00af\u0003\u00af\u0007\u00af\u0e13", + "\n\u00af\f\u00af\u000e\u00af\u0e16\u000b\u00af\u0003\u00b0\u0003\u00b0", + "\u0003\u00b0\u0003\u00b0\u0003\u00b0\u0003\u00b0\u0003\u00b0\u0005\u00b0", + "\u0e1f\n\u00b0\u0003\u00b1\u0003\u00b1\u0003\u00b1\u0003\u00b2\u0003", + "\u00b2\u0003\u00b3\u0003\u00b3\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003", + "\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003", + "\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003", + "\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0003", + "\u00b4\u0003\u00b4\u0003\u00b4\u0003\u00b4\u0005\u00b4\u0e41\n\u00b4", + "\u0003\u00b5\u0003\u00b5\u0003\u00b5\u0005\u00b5\u0e46\n\u00b5\u0003", + "\u00b6\u0003\u00b6\u0003\u00b6\u0005\u00b6\u0e4b\n\u00b6\u0003\u00b7", + "\u0003\u00b7\u0005\u00b7\u0e4f\n\u00b7\u0003\u00b8\u0003\u00b8\u0003", + "\u00b8\u0003\u00b8\u0003\u00b8\u0003\u00b8\u0005\u00b8\u0e57\n\u00b8", + "\u0005\u00b8\u0e59\n\u00b8\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003", + "\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0003\u00b9\u0005\u00b9\u0e93", + "\n\u00b9\u0003\u00ba\u0003\u00ba\u0003\u00ba\u0003\u00ba\u0003\u00ba", + "\u0003\u00ba\u0003\u00ba\u0003\u00ba\u0003\u00ba\u0003\u00ba\u0003\u00ba", + "\u0003\u00ba\u0003\u00bb\u0003\u00bb\u0003\u00bb\u0005\u00bb\u0ea4\n", + "\u00bb\u0003\u00bc\u0003\u00bc\u0003\u00bc\u0003\u00bc\u0003\u00bc\u0003", + "\u00bc\u0005\u00bc\u0eac\n\u00bc\u0003\u00bd\u0003\u00bd\u0003\u00bd", + "\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd", + "\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd", + "\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd\u0003\u00bd", + "\u0005\u00bd\u0ec3\n\u00bd\u0003\u00be\u0003\u00be\u0005\u00be\u0ec7", + "\n\u00be\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00bf", + "\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00bf", + "\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00bf\u0003\u00bf", + "\u0003\u00bf\u0005\u00bf\u0edb\n\u00bf\u0003\u00c0\u0003\u00c0\u0003", + "\u00c0\u0003\u00c0\u0003\u00c0\u0003\u00c0\u0003\u00c0\u0003\u00c0\u0003", + "\u00c0\u0003\u00c1\u0003\u00c1\u0003\u00c1\u0003\u00c1\u0003\u00c1\u0003", + "\u00c1\u0003\u00c1\u0003\u00c1\u0003\u00c1\u0003\u00c1\u0003\u00c1\u0003", + "\u00c2\u0003\u00c2\u0003\u00c2\u0003\u00c2\u0003\u00c2\u0003\u00c2\u0003", + "\u00c2\u0003\u00c2\u0003\u00c2\u0003\u00c3\u0003\u00c3\u0003\u00c3\u0003", + "\u00c3\u0003\u00c3\u0003\u00c3\u0005\u00c3\u0f00\n\u00c3\u0003\u00c4", + "\u0003\u00c4\u0003\u00c4\u0003\u00c4\u0003\u00c4\u0003\u00c4\u0003\u00c4", + "\u0005\u00c4\u0f09\n\u00c4\u0003\u00c5\u0003\u00c5\u0003\u00c5\u0005", + "\u00c5\u0f0e\n\u00c5\u0003\u00c6\u0003\u00c6\u0003\u00c6\u0005\u00c6", + "\u0f13\n\u00c6\u0003\u00c7\u0003\u00c7\u0003\u00c7\u0005\u00c7\u0f18", + "\n\u00c7\u0003\u00c8\u0003\u00c8\u0003\u00c8\u0005\u00c8\u0f1d\n\u00c8", + "\u0003\u00c9\u0003\u00c9\u0003\u00ca\u0003\u00ca\u0003\u00ca\u0003\u00ca", + "\u0003\u00ca\u0003\u00ca\u0003\u00ca\u0003\u00ca\u0003\u00ca\u0003\u00cb", + "\u0003\u00cb\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc", + "\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc", + "\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc", + "\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc", + "\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc", + "\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0003\u00cc", + "\u0003\u00cc\u0003\u00cc\u0003\u00cc\u0005\u00cc\u0f52\n\u00cc\u0003", + "\u00cd\u0003\u00cd\u0003\u00cd\u0003\u00cd\u0005\u00cd\u0f58\n\u00cd", + "\u0003\u00ce\u0003\u00ce\u0003\u00ce\u0007\u00ce\u0f5d\n\u00ce\f\u00ce", + "\u000e\u00ce\u0f60\u000b\u00ce\u0003\u00cf\u0003\u00cf\u0003\u00cf\u0003", + "\u00cf\u0003\u00cf\u0003\u00cf\u0003\u00cf\u0005\u00cf\u0f69\n\u00cf", + "\u0003\u00d0\u0003\u00d0\u0003\u00d0\u0005\u00d0\u0f6e\n\u00d0\u0003", + "\u00d1\u0006\u00d1\u0f71\n\u00d1\r\u00d1\u000e\u00d1\u0f72\u0003\u00d2", + "\u0003\u00d2\u0003\u00d2\u0003\u00d2\u0003\u00d2\u0003\u00d3\u0003\u00d3", + "\u0003\u00d4\u0003\u00d4\u0003\u00d5\u0003\u00d5\u0003\u00d6\u0003\u00d6", + "\u0003\u00d6\u0003\u00d6\u0003\u00d6\u0005\u00d6\u0f85\n\u00d6\u0003", + "\u00d7\u0003\u00d7\u0005\u00d7\u0f89\n\u00d7\u0003\u00d8\u0003\u00d8", + "\u0003\u00d9\u0003\u00d9\u0003\u00d9\u0003\u00d9\u0003\u00d9\u0003\u00d9", + "\u0005\u00d9\u0f93\n\u00d9\u0003\u00da\u0003\u00da\u0003\u00db\u0003", + "\u00db\u0005\u00db\u0f99\n\u00db\u0003\u00db\u0003\u00db\u0007\u00db", + "\u0f9d\n\u00db\f\u00db\u000e\u00db\u0fa0\u000b\u00db\u0003\u00dc\u0003", + "\u00dc\u0003\u00dc\u0003\u00dc\u0005\u00dc\u0fa6\n\u00dc\u0003\u00dd", + "\u0003\u00dd\u0003\u00dd\u0005\u00dd\u0fab\n\u00dd\u0003\u00de\u0007", + "\u00de\u0fae\n\u00de\f\u00de\u000e\u00de\u0fb1\u000b\u00de\u0003\u00df", + "\u0003\u00df\u0003\u00df\u0003\u00df\u0003\u00df\u0003\u00df\u0003\u00df", + "\u0003\u00df\u0003\u00df\u0003\u00df\u0003\u00df\u0005\u00df\u0fbe\n", + "\u00df\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003", + "\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003", + "\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003", + "\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003\u00e0\u0003", + "\u00e0\u0003\u00e0\u0003\u00e0\u0005\u00e0\u0fda\n\u00e0\u0003\u00e1", + "\u0003\u00e1\u0003\u00e1\u0007\u00e1\u0fdf\n\u00e1\f\u00e1\u000e\u00e1", + "\u0fe2\u000b\u00e1\u0003\u00e2\u0003\u00e2\u0003\u00e2\u0003\u00e2\u0003", + "\u00e2\u0003\u00e2\u0003\u00e3\u0003\u00e3\u0003\u00e3\u0007\u00e3\u0fed", + "\n\u00e3\f\u00e3\u000e\u00e3\u0ff0\u000b\u00e3\u0003\u00e4\u0003\u00e4", + "\u0003\u00e4\u0003\u00e4\u0003\u00e4\u0003\u00e4\u0003\u00e5\u0003\u00e5", + "\u0003\u00e5\u0003\u00e5\u0003\u00e5\u0003\u00e5\u0005\u00e5\u0ffe\n", + "\u00e5\u0003\u00e6\u0003\u00e6\u0003\u00e6\u0003\u00e6\u0003\u00e6\u0003", + "\u00e6\u0003\u00e6\u0003\u00e6\u0003\u00e6\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003\u00e7\u0003", + "\u00e7\u0003\u00e7\u0005\u00e7\u1073\n\u00e7\u0003\u00e8\u0003\u00e8", + "\u0003\u00e8\u0003\u00e8\u0003\u00e9\u0003\u00e9\u0003\u00e9\u0007\u00e9", + "\u107c\n\u00e9\f\u00e9\u000e\u00e9\u107f\u000b\u00e9\u0003\u00ea\u0003", + "\u00ea\u0003\u00ea\u0005\u00ea\u1084\n\u00ea\u0003\u00eb\u0003\u00eb", + "\u0003\u00eb\u0003\u00eb\u0003\u00eb\u0003\u00eb\u0005\u00eb\u108c\n", + "\u00eb\u0003\u00ec\u0003\u00ec\u0003\u00ec\u0003\u00ec\u0003\u00ed\u0003", + "\u00ed\u0003\u00ed\u0007\u00ed\u1095\n\u00ed\f\u00ed\u000e\u00ed\u1098", + "\u000b\u00ed\u0003\u00ee\u0003\u00ee\u0003\u00ee\u0003\u00ee\u0003\u00ef", + "\u0003\u00ef\u0005\u00ef\u10a0\n\u00ef\u0003\u00f0\u0003\u00f0\u0003", + "\u00f0\u0007\u00f0\u10a5\n\u00f0\f\u00f0\u000e\u00f0\u10a8\u000b\u00f0", + "\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1", + "\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1", + "\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1", + "\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1", + "\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1", + "\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1\u0003\u00f1", + "\u0003\u00f1\u0005\u00f1\u10cf\n\u00f1\u0003\u00f2\u0003\u00f2\u0003", + "\u00f2\u0003\u00f2\u0005\u00f2\u10d5\n\u00f2\u0003\u00f3\u0003\u00f3", + "\u0003\u00f3\u0003\u00f3\u0003\u00f3\u0003\u00f3\u0003\u00f3\u0003\u00f3", + "\u0003\u00f3\u0003\u00f3\u0003\u00f3\u0003\u00f3\u0003\u00f3\u0003\u00f3", + "\u0003\u00f4\u0003\u00f4\u0003\u00f4\u0007\u00f4\u10e8\n\u00f4\f\u00f4", + "\u000e\u00f4\u10eb\u000b\u00f4\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003", + "\u00f5\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003", + "\u00f5\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003", + "\u00f5\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0003", + "\u00f5\u0003\u00f5\u0003\u00f5\u0003\u00f5\u0005\u00f5\u1106\n\u00f5", + "\u0003\u00f6\u0003\u00f6\u0005\u00f6\u110a\n\u00f6\u0003\u00f7\u0003", + "\u00f7\u0003\u00f7\u0005\u00f7\u110f\n\u00f7\u0003\u00f8\u0003\u00f8", + "\u0003\u00f8\u0003\u00f8\u0003\u00f8\u0003\u00f8\u0003\u00f8\u0005\u00f8", + "\u1118\n\u00f8\u0003\u00f9\u0003\u00f9\u0005\u00f9\u111c\n\u00f9\u0003", + "\u00fa\u0003\u00fa\u0003\u00fa\u0003\u00fa\u0003\u00fa\u0003\u00fa\u0003", + "\u00fa\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003", + "\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003", + "\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003\u00fb\u0003", + "\u00fb\u0005\u00fb\u1137\n\u00fb\u0003\u00fc\u0003\u00fc\u0003\u00fc", + "\u0007\u00fc\u113c\n\u00fc\f\u00fc\u000e\u00fc\u113f\u000b\u00fc\u0003", + "\u00fd\u0003\u00fd\u0003\u00fd\u0003\u00fd\u0003\u00fd\u0003\u00fd\u0003", + "\u00fd\u0003\u00fd\u0003\u00fd\u0003\u00fd\u0003\u00fd\u0003\u00fd\u0005", + "\u00fd\u114d\n\u00fd\u0003\u00fe\u0003\u00fe\u0003\u00fe\u0003\u00fe", + "\u0003\u00fe\u0003\u00fe\u0003\u00fe\u0003\u00fe\u0003\u00fe\u0003\u00fe", + "\u0003\u00fe\u0003\u00fe\u0003\u00fe\u0003\u00fe\u0003\u00fe\u0003\u00fe", + "\u0003\u00fe\u0003\u00fe\u0005\u00fe\u1161\n\u00fe\u0003\u00ff\u0003", + "\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003", + "\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003", + "\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0003\u00ff\u0005\u00ff\u1175", + "\n\u00ff\u0003\u0100\u0003\u0100\u0003\u0100\u0003\u0100\u0003\u0100", + "\u0003\u0100\u0003\u0101\u0003\u0101\u0003\u0101\u0003\u0101\u0003\u0101", + "\u0003\u0101\u0003\u0101\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102\u0003\u0102", + "\u0003\u0102\u0003\u0102\u0005\u0102\u11d2\n\u0102\u0003\u0103\u0003", + "\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003", + "\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003", + "\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0003", + "\u0103\u0003\u0103\u0003\u0103\u0003\u0103\u0005\u0103\u11eb\n\u0103", + "\u0003\u0104\u0003\u0104\u0003\u0104\u0003\u0104\u0003\u0104\u0005\u0104", + "\u11f2\n\u0104\u0003\u0105\u0003\u0105\u0003\u0105\u0003\u0105\u0003", + "\u0105\u0003\u0105\u0003\u0105\u0003\u0105\u0003\u0105\u0003\u0105\u0003", + "\u0105\u0003\u0105\u0003\u0105\u0003\u0105\u0005\u0105\u1202\n\u0105", + "\u0003\u0106\u0003\u0106\u0003\u0107\u0003\u0107\u0003\u0107\u0007\u0107", + "\u1209\n\u0107\f\u0107\u000e\u0107\u120c\u000b\u0107\u0003\u0108\u0003", + "\u0108\u0005\u0108\u1210\n\u0108\u0003\u0109\u0003\u0109\u0006\u0109", + "\u1214\n\u0109\r\u0109\u000e\u0109\u1215\u0003\u010a\u0003\u010a\u0003", + "\u010a\u0007\u010a\u121b\n\u010a\f\u010a\u000e\u010a\u121e\u000b\u010a", + "\u0003\u010b\u0003\u010b\u0003\u010b\u0003\u010b\u0003\u010b\u0003\u010b", + "\u0003\u010c\u0003\u010c\u0003\u010c\u0003\u010c\u0003\u010c\u0005\u010c", + "\u122b\n\u010c\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003", + "\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0003\u010d\u0005\u010d\u12c0", + "\n\u010d\u0003\u010e\u0003\u010e\u0005\u010e\u12c4\n\u010e\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f\u0003\u010f", + "\u0005\u010f\u1321\n\u010f\u0003\u0110\u0003\u0110\u0003\u0110\u0005", + "\u0110\u1326\n\u0110\u0003\u0111\u0003\u0111\u0005\u0111\u132a\n\u0111", + "\u0003\u0112\u0003\u0112\u0003\u0112\u0003\u0112\u0005\u0112\u1330\n", + "\u0112\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003\u0113\u0003", + "\u0113\u0005\u0113\u1374\n\u0113\u0003\u0114\u0003\u0114\u0003\u0115", + "\u0003\u0115\u0005\u0115\u137a\n\u0115\u0003\u0116\u0003\u0116\u0003", + "\u0116\u0003\u0116\u0003\u0116\u0003\u0116\u0003\u0116\u0003\u0116\u0003", + "\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003", + "\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003", + "\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003\u0117\u0003", + "\u0117\u0005\u0117\u1397\n\u0117\u0003\u0118\u0003\u0118\u0003\u0118", + "\u0003\u0118\u0003\u0118\u0003\u0118\u0003\u0118\u0003\u0118\u0003\u0118", + "\u0003\u0118\u0003\u0118\u0003\u0118\u0003\u0118\u0003\u0118\u0003\u0118", + "\u0005\u0118\u13a8\n\u0118\u0003\u0119\u0003\u0119\u0003\u0119\u0007", + "\u0119\u13ad\n\u0119\f\u0119\u000e\u0119\u13b0\u000b\u0119\u0003\u011a", + "\u0003\u011a\u0003\u011a\u0003\u011a\u0003\u011a\u0003\u011a\u0003\u011a", + "\u0003\u011a\u0003\u011a\u0005\u011a\u13bb\n\u011a\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003\u011b\u0003", + "\u011b\u0003\u011b\u0003\u011b\u0005\u011b\u13f7\n\u011b\u0003\u011c", + "\u0003\u011c\u0003\u011c\u0007\u011c\u13fc\n\u011c\f\u011c\u000e\u011c", + "\u13ff\u000b\u011c\u0003\u011d\u0003\u011d\u0003\u011d\u0005\u011d\u1404", + "\n\u011d\u0003\u011e\u0003\u011e\u0003\u011e\u0003\u011e\u0005\u011e", + "\u140a\n\u011e\u0003\u011f\u0003\u011f\u0003\u011f\u0003\u011f\u0003", + "\u011f\u0003\u011f\u0003\u011f\u0003\u0120\u0003\u0120\u0003\u0120\u0003", + "\u0120\u0003\u0120\u0003\u0120\u0003\u0120\u0003\u0120\u0003\u0120\u0003", + "\u0120\u0003\u0120\u0003\u0120\u0003\u0120\u0003\u0120\u0003\u0120\u0003", + "\u0120\u0003\u0120\u0005\u0120\u1424\n\u0120\u0003\u0121\u0003\u0121", + "\u0003\u0121\u0003\u0121\u0005\u0121\u142a\n\u0121\u0003\u0122\u0003", + "\u0122\u0003\u0122\u0003\u0122\u0005\u0122\u1430\n\u0122\u0003\u0123", + "\u0003\u0123\u0003\u0123\u0003\u0123\u0003\u0123\u0003\u0123\u0003\u0124", + "\u0007\u0124\u1439\n\u0124\f\u0124\u000e\u0124\u143c\u000b\u0124\u0003", + "\u0125\u0003\u0125\u0003\u0125\u0003\u0125\u0003\u0125\u0003\u0125\u0003", + "\u0125\u0003\u0125\u0003\u0125\u0005\u0125\u1447\n\u0125\u0003\u0126", + "\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126", + "\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126", + "\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126", + "\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126\u0003\u0126", + "\u0003\u0126\u0003\u0126\u0005\u0126\u1464\n\u0126\u0003\u0127\u0003", + "\u0127\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003", + "\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003", + "\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003", + "\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003", + "\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003", + "\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0003\u0128\u0005", + "\u0128\u148b\n\u0128\u0003\u0129\u0003\u0129\u0005\u0129\u148f\n\u0129", + "\u0003\u012a\u0003\u012a\u0005\u012a\u1493\n\u012a\u0003\u012b\u0003", + "\u012b\u0005\u012b\u1497\n\u012b\u0003\u012c\u0003\u012c\u0003\u012c", + "\u0005\u012c\u149c\n\u012c\u0003\u012d\u0003\u012d\u0003\u012d\u0007", + "\u012d\u14a1\n\u012d\f\u012d\u000e\u012d\u14a4\u000b\u012d\u0003\u012e", + "\u0003\u012e\u0003\u012e\u0003\u012e\u0003\u012e\u0003\u012e\u0003\u012e", + "\u0003\u012e\u0003\u012e\u0003\u012e\u0003\u012e\u0005\u012e\u14b1\n", + "\u012e\u0003\u012f\u0003\u012f\u0003\u012f\u0003\u012f\u0003\u012f\u0003", + "\u012f\u0003\u012f\u0003\u012f\u0003\u012f\u0003\u012f\u0003\u012f\u0005", + "\u012f\u14be\n\u012f\u0003\u0130\u0003\u0130\u0003\u0130\u0003\u0130", + "\u0003\u0130\u0003\u0130\u0005\u0130\u14c6\n\u0130\u0003\u0131\u0003", + "\u0131\u0003\u0131\u0007\u0131\u14cb\n\u0131\f\u0131\u000e\u0131\u14ce", + "\u000b\u0131\u0003\u0132\u0003\u0132\u0003\u0132\u0005\u0132\u14d3\n", + "\u0132\u0003\u0133\u0003\u0133\u0005\u0133\u14d7\n\u0133\u0003\u0134", + "\u0003\u0134\u0003\u0134\u0005\u0134\u14dc\n\u0134\u0003\u0135\u0003", + "\u0135\u0003\u0135\u0003\u0135\u0003\u0135\u0005\u0135\u14e3\n\u0135", + "\u0003\u0136\u0003\u0136\u0003\u0136\u0003\u0136\u0003\u0136\u0003\u0136", + "\u0003\u0136\u0003\u0136\u0003\u0136\u0003\u0136\u0003\u0136\u0003\u0136", + "\u0005\u0136\u14f1\n\u0136\u0005\u0136\u14f3\n\u0136\u0003\u0136\u0003", + "\u0136\u0003\u0137\u0003\u0137\u0003\u0137\u0005\u0137\u14fa\n\u0137", + "\u0003\u0138\u0003\u0138\u0005\u0138\u14fe\n\u0138\u0003\u0138\u0003", + "\u0138\u0003\u0139\u0003\u0139\u0003\u0139\u0007\u0139\u1505\n\u0139", + "\f\u0139\u000e\u0139\u1508\u000b\u0139\u0003\u013a\u0003\u013a\u0003", + "\u013a\u0007\u013a\u150d\n\u013a\f\u013a\u000e\u013a\u1510\u000b\u013a", + "\u0003\u013b\u0003\u013b\u0003\u013b\u0003\u013b\u0003\u013b\u0003\u013b", + "\u0005\u013b\u1518\n\u013b\u0005\u013b\u151a\n\u013b\u0003\u013c\u0003", + "\u013c\u0005\u013c\u151e\n\u013c\u0003\u013c\u0003\u013c\u0003\u013d", + "\u0003\u013d\u0003\u013d\u0007\u013d\u1525\n\u013d\f\u013d\u000e\u013d", + "\u1528\u000b\u013d\u0003\u013e\u0003\u013e\u0005\u013e\u152c\n\u013e", + "\u0003\u013e\u0003\u013e\u0003\u013e\u0003\u013e\u0005\u013e\u1532\n", + "\u013e\u0003\u013e\u0003\u013e\u0003\u013e\u0005\u013e\u1537\n\u013e", + "\u0003\u013f\u0003\u013f\u0005\u013f\u153b\n\u013f\u0003\u013f\u0003", + "\u013f\u0003\u013f\u0005\u013f\u1540\n\u013f\u0003\u0140\u0003\u0140", + "\u0003\u0141\u0003\u0141\u0003\u0142\u0003\u0142\u0003\u0142\u0003\u0142", + "\u0003\u0142\u0003\u0142\u0003\u0142\u0003\u0142\u0003\u0142\u0003\u0142", + "\u0003\u0142\u0003\u0142\u0005\u0142\u1552\n\u0142\u0003\u0143\u0003", + "\u0143\u0003\u0143\u0005\u0143\u1557\n\u0143\u0003\u0144\u0003\u0144", + "\u0003\u0145\u0003\u0145\u0003\u0145\u0003\u0145\u0003\u0145\u0003\u0145", + "\u0003\u0145\u0003\u0145\u0003\u0145\u0003\u0145\u0003\u0145\u0005\u0145", + "\u1566\n\u0145\u0003\u0145\u0003\u0145\u0003\u0146\u0003\u0146\u0003", + "\u0146\u0007\u0146\u156d\n\u0146\f\u0146\u000e\u0146\u1570\u000b\u0146", + "\u0003\u0147\u0003\u0147\u0003\u0147\u0003\u0148\u0003\u0148\u0003\u0148", + "\u0007\u0148\u1578\n\u0148\f\u0148\u000e\u0148\u157b\u000b\u0148\u0003", + "\u0149\u0006\u0149\u157e\n\u0149\r\u0149\u000e\u0149\u157f\u0003\u0149", + "\u0003\u0149\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a", + "\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a", + "\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a", + "\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a", + "\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a", + "\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a\u0003\u014a", + "\u0005\u014a\u15a7\n\u014a\u0003\u014b\u0003\u014b\u0003\u014b\u0003", + "\u014b\u0003\u014b\u0003\u014b\u0003\u014b\u0003\u014b\u0005\u014b\u15b1", + "\n\u014b\u0003\u014c\u0003\u014c\u0003\u014c\u0003\u014c\u0003\u014c", + "\u0005\u014c\u15b8\n\u014c\u0003\u014d\u0003\u014d\u0003\u014d\u0003", + "\u014d\u0003\u014d\u0003\u014d\u0003\u014d\u0007\u014d\u15c1\n\u014d", + "\f\u014d\u000e\u014d\u15c4\u000b\u014d\u0003\u014e\u0003\u014e\u0003", + "\u014e\u0005\u014e\u15c9\n\u014e\u0003\u014f\u0003\u014f\u0003\u014f", + "\u0003\u0150\u0003\u0150\u0003\u0150\u0007\u0150\u15d1\n\u0150\f\u0150", + "\u000e\u0150\u15d4\u000b\u0150\u0003\u0151\u0003\u0151\u0003\u0151\u0003", + "\u0151\u0003\u0151\u0003\u0151\u0003\u0152\u0006\u0152\u15dd\n\u0152", + "\r\u0152\u000e\u0152\u15de\u0003\u0153\u0003\u0153\u0005\u0153\u15e3", + "\n\u0153\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154", + "\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154", + "\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154", + "\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154", + "\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154", + "\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154\u0003\u0154", + "\u0003\u0154\u0005\u0154\u1609\n\u0154\u0003\u0155\u0003\u0155\u0003", + "\u0155\u0003\u0155\u0003\u0155\u0003\u0155\u0003\u0155\u0003\u0155\u0003", + "\u0155\u0003\u0155\u0003\u0155\u0003\u0155\u0005\u0155\u1617\n\u0155", + "\u0003\u0156\u0003\u0156\u0003\u0156\u0003\u0156\u0003\u0156\u0003\u0156", + "\u0003\u0156\u0003\u0156\u0003\u0156\u0003\u0156\u0003\u0156\u0003\u0156", + "\u0005\u0156\u1625\n\u0156\u0003\u0157\u0003\u0157\u0003\u0157\u0003", + "\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003", + "\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003", + "\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003\u0157\u0003", + "\u0157\u0005\u0157\u163d\n\u0157\u0003\u0158\u0003\u0158\u0003\u0158", + "\u0007\u0158\u1642\n\u0158\f\u0158\u000e\u0158\u1645\u000b\u0158\u0003", + "\u0158\u0003\u0158\u0003\u0159\u0003\u0159\u0003\u0159\u0007\u0159\u164c", + "\n\u0159\f\u0159\u000e\u0159\u164f\u000b\u0159\u0003\u015a\u0003\u015a", + "\u0003\u015a\u0003\u015b\u0003\u015b\u0003\u015b\u0003\u015c\u0006\u015c", + "\u1658\n\u015c\r\u015c\u000e\u015c\u1659\u0003\u015d\u0003\u015d\u0003", + "\u015d\u0005\u015d\u165f\n\u015d\u0003\u015e\u0003\u015e\u0003\u015e", + "\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e", + "\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e", + "\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e", + "\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e", + "\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e\u0003\u015e", + "\u0003\u015e\u0005\u015e\u1683\n\u015e\u0003\u015f\u0003\u015f\u0003", + "\u015f\u0003\u015f\u0003\u015f\u0005\u015f\u168a\n\u015f\u0003\u0160", + "\u0003\u0160\u0003\u0160\u0003\u0160\u0003\u0160\u0003\u0160\u0003\u0160", + "\u0003\u0160\u0003\u0160\u0003\u0160\u0003\u0161\u0003\u0161\u0003\u0161", + "\u0005\u0161\u1699\n\u0161\u0003\u0162\u0003\u0162\u0003\u0162\u0003", + "\u0162\u0003\u0162\u0003\u0162\u0003\u0162\u0003\u0162\u0003\u0162\u0003", + "\u0162\u0003\u0162\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003", + "\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003", + "\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003", + "\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003", + "\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003", + "\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0003\u0163\u0005", + "\u0163\u16c8\n\u0163\u0003\u0164\u0003\u0164\u0003\u0164\u0003\u0164", + "\u0003\u0164\u0003\u0164\u0003\u0164\u0003\u0164\u0003\u0164\u0003\u0165", + "\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165", + "\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165", + "\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165", + "\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165\u0003\u0165", + "\u0003\u0165\u0005\u0165\u16ed\n\u0165\u0003\u0166\u0003\u0166\u0003", + "\u0167\u0003\u0167\u0003\u0168\u0003\u0168\u0003\u0168\u0007\u0168\u16f6", + "\n\u0168\f\u0168\u000e\u0168\u16f9\u000b\u0168\u0003\u0169\u0003\u0169", + "\u0003\u016a\u0003\u016a\u0003\u016a\u0003\u016a\u0003\u016a\u0003\u016a", + "\u0003\u016a\u0003\u016a\u0003\u016a\u0003\u016a\u0003\u016a\u0003\u016a", + "\u0005\u016a\u1709\n\u016a\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003\u016b\u0003", + "\u016b\u0003\u016b\u0003\u016b\u0005\u016b\u18df\n\u016b\u0003\u016c", + "\u0003\u016c\u0005\u016c\u18e3\n\u016c\u0003\u016d\u0003\u016d\u0003", + "\u016d\u0005\u016d\u18e8\n\u016d\u0003\u016e\u0003\u016e\u0003\u016e", + "\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e", + "\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e", + "\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e", + "\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e", + "\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e", + "\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e", + "\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e", + "\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e", + "\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e\u0003\u016e", + "\u0005\u016e\u1923\n\u016e\u0003\u016f\u0003\u016f\u0005\u016f\u1927", + "\n\u016f\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170\u0003\u0170", + "\u0003\u0170\u0003\u0170\u0005\u0170\u1a02\n\u0170\u0003\u0171\u0003", + "\u0171\u0003\u0171\u0003\u0171\u0003\u0171\u0003\u0171\u0003\u0171\u0003", + "\u0171\u0003\u0172\u0003\u0172\u0003\u0172\u0007\u0172\u1a0f\n\u0172", + "\f\u0172\u000e\u0172\u1a12\u000b\u0172\u0003\u0173\u0003\u0173\u0003", + "\u0173\u0003\u0173\u0003\u0173\u0003\u0173\u0003\u0173\u0003\u0173\u0005", + "\u0173\u1a1c\n\u0173\u0003\u0174\u0003\u0174\u0003\u0174\u0003\u0174", + "\u0003\u0174\u0005\u0174\u1a23\n\u0174\u0003\u0175\u0003\u0175\u0003", + "\u0175\u0003\u0175\u0003\u0175\u0003\u0175\u0003\u0175\u0003\u0175\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003\u0176\u0003", + "\u0176\u0003\u0176\u0003\u0176\u0005\u0176\u1ae4\n\u0176\u0003\u0177", + "\u0003\u0177\u0003\u0177\u0003\u0177\u0003\u0177\u0003\u0177\u0003\u0178", + "\u0003\u0178\u0005\u0178\u1aee\n\u0178\u0003\u0179\u0003\u0179\u0003", + "\u0179\u0003\u0179\u0003\u0179\u0003\u0179\u0005\u0179\u1af6\n\u0179", + "\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a", + "\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a", + "\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a", + "\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a\u0003\u017a", + "\u0003\u017a\u0003\u017a\u0003\u017a\u0005\u017a\u1b13\n\u017a\u0003", + "\u017b\u0003\u017b\u0003\u017b\u0003\u017b\u0003\u017b\u0003\u017b\u0003", + "\u017b\u0003\u017b\u0003\u017b\u0003\u017c\u0003\u017c\u0003\u017c\u0007", + "\u017c\u1b21\n\u017c\f\u017c\u000e\u017c\u1b24\u000b\u017c\u0003\u017d", + "\u0003\u017d\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e", + "\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e", + "\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e", + "\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e", + "\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e", + "\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e\u0003\u017e", + "\u0003\u017e\u0003\u017e\u0005\u017e\u1b4d\n\u017e\u0003\u017f\u0003", + "\u017f\u0003\u017f\u0003\u017f\u0003\u017f\u0003\u017f\u0003\u017f\u0003", + "\u017f\u0003\u017f\u0003\u017f\u0003\u017f\u0003\u017f\u0005\u017f\u1b5b", + "\n\u017f\u0003\u0180\u0003\u0180\u0003\u0180\u0003\u0180\u0003\u0180", + "\u0003\u0180\u0003\u0180\u0003\u0180\u0003\u0180\u0003\u0180\u0003\u0180", + "\u0003\u0180\u0003\u0180\u0003\u0180\u0003\u0181\u0003\u0181\u0003\u0181", + "\u0003\u0181\u0003\u0181\u0003\u0181\u0005\u0181\u1b71\n\u0181\u0003", + "\u0182\u0003\u0182\u0003\u0182\u0007\u0182\u1b76\n\u0182\f\u0182\u000e", + "\u0182\u1b79\u000b\u0182\u0003\u0183\u0003\u0183\u0003\u0183\u0003\u0183", + "\u0003\u0183\u0005\u0183\u1b80\n\u0183\u0003\u0184\u0003\u0184\u0005", + "\u0184\u1b84\n\u0184\u0003\u0185\u0003\u0185\u0003\u0186\u0003\u0186", + "\u0003\u0186\u0005\u0186\u1b8b\n\u0186\u0003\u0187\u0003\u0187\u0003", + "\u0187\u0003\u0187\u0003\u0188\u0003\u0188\u0003\u0188\u0005\u0188\u1b94", + "\n\u0188\u0003\u0189\u0003\u0189\u0003\u0189\u0003\u018a\u0003\u018a", + "\u0003\u018a\u0003\u018a\u0005\u018a\u1b9d\n\u018a\u0003\u018b\u0003", + "\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003", + "\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003", + "\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003", + "\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003", + "\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003", + "\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003", + "\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003", + "\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003\u018b\u0003", + "\u018b\u0005\u018b\u1bd1\n\u018b\u0003\u018c\u0003\u018c\u0003\u018c", + "\u0005\u018c\u1bd6\n\u018c\u0003\u018d\u0003\u018d\u0003\u018d\u0003", + "\u018d\u0003\u018d\u0003\u018d\u0003\u018d\u0003\u018d\u0003\u018d\u0003", + "\u018d\u0005\u018d\u1be2\n\u018d\u0003\u018e\u0003\u018e\u0005\u018e", + "\u1be6\n\u018e\u0003\u018e\u0007\u018e\u1be9\n\u018e\f\u018e\u000e\u018e", + "\u1bec\u000b\u018e\u0003\u018f\u0003\u018f\u0005\u018f\u1bf0\n\u018f", + "\u0003\u0190\u0003\u0190\u0005\u0190\u1bf4\n\u0190\u0003\u0190\u0003", + "\u0190\u0005\u0190\u1bf8\n\u0190\u0003\u0191\u0003\u0191\u0003\u0191", + "\u0005\u0191\u1bfd\n\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0003", + "\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0003", + "\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0005\u0191\u1c0d", + "\n\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0003\u0191\u0003\u0192", + "\u0003\u0192\u0005\u0192\u1c15\n\u0192\u0003\u0192\u0003\u0192\u0003", + "\u0192\u0005\u0192\u1c1a\n\u0192\u0003\u0193\u0003\u0193\u0003\u0193", + "\u0003\u0194\u0003\u0194\u0003\u0194\u0003\u0194\u0003\u0194\u0003\u0194", + "\u0003\u0195\u0003\u0195\u0005\u0195\u1c27\n\u0195\u0003\u0196\u0006", + "\u0196\u1c2a\n\u0196\r\u0196\u000e\u0196\u1c2b\u0003\u0197\u0003\u0197", + "\u0003\u0197\u0003\u0197\u0003\u0197\u0005\u0197\u1c33\n\u0197\u0003", + "\u0198\u0003\u0198\u0003\u0198\u0003\u0198\u0003\u0198\u0003\u0198\u0003", + "\u0198\u0003\u0198\u0005\u0198\u1c3d\n\u0198\u0003\u0199\u0003\u0199", + "\u0005\u0199\u1c41\n\u0199\u0003\u019a\u0003\u019a\u0003\u019a\u0003", + "\u019a\u0003\u019a\u0003\u019a\u0003\u019a\u0003\u019a\u0003\u019a\u0005", + "\u019a\u1c4c\n\u019a\u0003\u019b\u0003\u019b\u0003\u019b\u0003\u019b", + "\u0003\u019b\u0003\u019c\u0003\u019c\u0003\u019c\u0003\u019c\u0005\u019c", + "\u1c57\n\u019c\u0003\u019c\u0003\u019c\u0003\u019c\u0003\u019c\u0003", + "\u019c\u0003\u019c\u0005\u019c\u1c5f\n\u019c\u0003\u019d\u0003\u019d", + "\u0003\u019d\u0007\u019d\u1c64\n\u019d\f\u019d\u000e\u019d\u1c67\u000b", + "\u019d\u0003\u019e\u0003\u019e\u0003\u019f\u0003\u019f\u0003\u019f\u0003", + "\u019f\u0003\u019f\u0003\u019f\u0003\u01a0\u0003\u01a0\u0003\u01a0\u0003", + "\u01a0\u0003\u01a0\u0003\u01a1\u0003\u01a1\u0003\u01a1\u0003\u01a1\u0003", + "\u01a1\u0003\u01a1\u0003\u01a1\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0003", + "\u01a2\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0003", + "\u01a2\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0003", + "\u01a2\u0005\u01a2\u1c8d\n\u01a2\u0003\u01a2\u0003\u01a2\u0003\u01a2", + "\u0003\u01a2\u0003\u01a2\u0003\u01a2\u0005\u01a2\u1c95\n\u01a2\u0003", + "\u01a3\u0003\u01a3\u0005\u01a3\u1c99\n\u01a3\u0003\u01a4\u0003\u01a4", + "\u0003\u01a4\u0003\u01a4\u0003\u01a4\u0003\u01a4\u0003\u01a4\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5", + "\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0003\u01a5\u0005\u01a5", + "\u1cea\n\u01a5\u0003\u01a6\u0003\u01a6\u0003\u01a7\u0003\u01a7\u0003", + "\u01a7\u0003\u01a7\u0003\u01a7\u0003\u01a7\u0003\u01a7\u0003\u01a7\u0003", + "\u01a7\u0003\u01a7\u0003\u01a7\u0003\u01a8\u0003\u01a8\u0003\u01a8\u0003", + "\u01a8\u0003\u01a8\u0003\u01a8\u0003\u01a8\u0003\u01a8\u0003\u01a8\u0003", + "\u01a8\u0003\u01a8\u0003\u01a8\u0003\u01a8\u0005\u01a8\u1d06\n\u01a8", + "\u0003\u01a9\u0003\u01a9\u0003\u01a9\u0005\u01a9\u1d0b\n\u01a9\u0003", + "\u01aa\u0003\u01aa\u0003\u01aa\u0003\u01aa\u0003\u01aa\u0003\u01aa\u0003", + "\u01aa\u0003\u01aa\u0003\u01aa\u0003\u01aa\u0003\u01aa\u0003\u01aa\u0003", + "\u01aa\u0005\u01aa\u1d1a\n\u01aa\u0003\u01ab\u0003\u01ab\u0003\u01ab", + "\u0003\u01ab\u0003\u01ab\u0003\u01ab\u0003\u01ab\u0003\u01ab\u0003\u01ab", + "\u0003\u01ab\u0005\u01ab\u1d26\n\u01ab\u0003\u01ac\u0003\u01ac\u0003", + "\u01ac\u0007\u01ac\u1d2b\n\u01ac\f\u01ac\u000e\u01ac\u1d2e\u000b\u01ac", + "\u0003\u01ad\u0003\u01ad\u0003\u01ae\u0003\u01ae\u0003\u01ae\u0003\u01af", + "\u0003\u01af\u0005\u01af\u1d37\n\u01af\u0003\u01b0\u0003\u01b0\u0003", + "\u01b0\u0005\u01b0\u1d3c\n\u01b0\u0003\u01b1\u0003\u01b1\u0005\u01b1", + "\u1d40\n\u01b1\u0003\u01b2\u0003\u01b2\u0005\u01b2\u1d44\n\u01b2\u0003", + "\u01b3\u0003\u01b3\u0005\u01b3\u1d48\n\u01b3\u0003\u01b4\u0003\u01b4", + "\u0005\u01b4\u1d4c\n\u01b4\u0003\u01b5\u0003\u01b5\u0003\u01b5\u0003", + "\u01b5\u0003\u01b5\u0005\u01b5\u1d53\n\u01b5\u0003\u01b6\u0003\u01b6", + "\u0003\u01b6\u0003\u01b7\u0003\u01b7\u0003\u01b7\u0007\u01b7\u1d5b\n", + "\u01b7\f\u01b7\u000e\u01b7\u1d5e\u000b\u01b7\u0003\u01b8\u0003\u01b8", + "\u0005\u01b8\u1d62\n\u01b8\u0003\u01b9\u0003\u01b9\u0003\u01b9\u0003", + "\u01b9\u0003\u01b9\u0003\u01b9\u0003\u01b9\u0003\u01b9\u0003\u01b9\u0003", + "\u01b9\u0003\u01b9\u0003\u01b9\u0003\u01b9\u0003\u01b9\u0003\u01b9\u0003", + "\u01b9\u0005\u01b9\u1d74\n\u01b9\u0003\u01ba\u0003\u01ba\u0003\u01ba", + "\u0003\u01ba\u0003\u01ba\u0003\u01ba\u0003\u01ba\u0003\u01ba\u0003\u01ba", + "\u0005\u01ba\u1d7f\n\u01ba\u0003\u01bb\u0003\u01bb\u0003\u01bb\u0007", + "\u01bb\u1d84\n\u01bb\f\u01bb\u000e\u01bb\u1d87\u000b\u01bb\u0003\u01bc", + "\u0003\u01bc\u0003\u01bc\u0003\u01bd\u0003\u01bd\u0005\u01bd\u1d8e\n", + "\u01bd\u0003\u01be\u0003\u01be\u0003\u01be\u0005\u01be\u1d93\n\u01be", + "\u0003\u01bf\u0003\u01bf\u0003\u01bf\u0003\u01bf\u0003\u01bf\u0003\u01bf", + "\u0003\u01c0\u0003\u01c0\u0003\u01c0\u0003\u01c0\u0003\u01c0\u0005\u01c0", + "\u1da0\n\u01c0\u0003\u01c1\u0003\u01c1\u0003\u01c1\u0003\u01c1\u0005", + "\u01c1\u1da6\n\u01c1\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2", + "\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2", + "\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2", + "\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2", + "\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0003\u01c2\u0005\u01c2", + "\u1dc3\n\u01c2\u0003\u01c3\u0003\u01c3\u0003\u01c3\u0003\u01c3\u0003", + "\u01c3\u0005\u01c3\u1dca\n\u01c3\u0003\u01c4\u0003\u01c4\u0003\u01c4", + "\u0003\u01c4\u0003\u01c4\u0003\u01c4\u0003\u01c4\u0003\u01c4\u0003\u01c4", + "\u0003\u01c4\u0005\u01c4\u1dd6\n\u01c4\u0003\u01c5\u0003\u01c5\u0003", + "\u01c5\u0003\u01c5\u0003\u01c5\u0003\u01c5\u0003\u01c5\u0003\u01c5\u0003", + "\u01c6\u0003\u01c6\u0003\u01c6\u0005\u01c6\u1de3\n\u01c6\u0003\u01c7", + "\u0003\u01c7\u0003\u01c7\u0003\u01c7\u0003\u01c7\u0003\u01c7\u0003\u01c7", + "\u0003\u01c7\u0003\u01c7\u0003\u01c7\u0003\u01c7\u0003\u01c7\u0003\u01c7", + "\u0005\u01c7\u1df2\n\u01c7\u0003\u01c7\u0003\u01c7\u0003\u01c7\u0003", + "\u01c7\u0005\u01c7\u1df8\n\u01c7\u0003\u01c8\u0003\u01c8\u0003\u01c9", + "\u0003\u01c9\u0003\u01c9\u0007\u01c9\u1dff\n\u01c9\f\u01c9\u000e\u01c9", + "\u1e02\u000b\u01c9\u0003\u01ca\u0003\u01ca\u0003\u01ca\u0003\u01cb\u0003", + "\u01cb\u0003\u01cb\u0003\u01cb\u0003\u01cb\u0003\u01cb\u0003\u01cb\u0003", + "\u01cb\u0003\u01cb\u0003\u01cb\u0005\u01cb\u1e11\n\u01cb\u0003\u01cb", + "\u0005\u01cb\u1e14\n\u01cb\u0003\u01cc\u0003\u01cc\u0003\u01cc\u0003", + "\u01cc\u0003\u01cc\u0003\u01cc\u0003\u01cc\u0003\u01cc\u0003\u01cc\u0005", + "\u01cc\u1e1f\n\u01cc\u0003\u01cd\u0003\u01cd\u0003\u01cd\u0005\u01cd", + "\u1e24\n\u01cd\u0003\u01ce\u0003\u01ce\u0003\u01ce\u0003\u01ce\u0003", + "\u01ce\u0003\u01ce\u0003\u01ce\u0003\u01ce\u0003\u01cf\u0003\u01cf\u0003", + "\u01cf\u0005\u01cf\u1e31\n\u01cf\u0003\u01d0\u0003\u01d0\u0003\u01d0", + "\u0003\u01d0\u0003\u01d0\u0003\u01d0\u0003\u01d1\u0003\u01d1\u0003\u01d1", + "\u0003\u01d1\u0003\u01d1\u0005\u01d1\u1e3e\n\u01d1\u0003\u01d2\u0003", + "\u01d2\u0003\u01d2\u0003\u01d2\u0003\u01d2\u0003\u01d2\u0003\u01d2\u0003", + "\u01d2\u0003\u01d2\u0005\u01d2\u1e49\n\u01d2\u0003\u01d2\u0005\u01d2", + "\u1e4c\n\u01d2\u0003\u01d3\u0003\u01d3\u0005\u01d3\u1e50\n\u01d3\u0003", + "\u01d4\u0003\u01d4\u0003\u01d4\u0003\u01d4\u0005\u01d4\u1e56\n\u01d4", + "\u0003\u01d5\u0003\u01d5\u0003\u01d5\u0003\u01d5\u0003\u01d5\u0003\u01d5", + "\u0003\u01d5\u0003\u01d5\u0003\u01d5\u0003\u01d6\u0003\u01d6\u0003\u01d6", + "\u0007\u01d6\u1e64\n\u01d6\f\u01d6\u000e\u01d6\u1e67\u000b\u01d6\u0003", + "\u01d7\u0003\u01d7\u0003\u01d7\u0003\u01d7\u0003\u01d7\u0003\u01d7\u0003", + "\u01d7\u0003\u01d7\u0003\u01d7\u0003\u01d7\u0005\u01d7\u1e73\n\u01d7", + "\u0003\u01d8\u0003\u01d8\u0003\u01d8\u0003\u01d9\u0003\u01d9\u0003\u01d9", + "\u0007\u01d9\u1e7b\n\u01d9\f\u01d9\u000e\u01d9\u1e7e\u000b\u01d9\u0003", + "\u01da\u0003\u01da\u0003\u01da\u0003\u01da\u0003\u01da\u0003\u01da\u0003", + "\u01da\u0003\u01da\u0003\u01db\u0003\u01db\u0003\u01dc\u0003\u01dc\u0003", + "\u01dc\u0003\u01dc\u0003\u01dc\u0007\u01dc\u1e8f\n\u01dc\f\u01dc\u000e", + "\u01dc\u1e92\u000b\u01dc\u0003\u01dd\u0003\u01dd\u0003\u01dd\u0003\u01dd", + "\u0003\u01dd\u0005\u01dd\u1e99\n\u01dd\u0003\u01de\u0003\u01de\u0005", + "\u01de\u1e9d\n\u01de\u0003\u01df\u0003\u01df\u0003\u01df\u0003\u01df", + "\u0003\u01df\u0003\u01df\u0003\u01df\u0003\u01df\u0005\u01df\u1ea7\n", + "\u01df\u0003\u01e0\u0003\u01e0\u0003\u01e0\u0003\u01e0\u0003\u01e0\u0003", + "\u01e0\u0003\u01e0\u0003\u01e0\u0005\u01e0\u1eb1\n\u01e0\u0003\u01e0", + "\u0003\u01e0\u0003\u01e0\u0003\u01e0\u0003\u01e0\u0003\u01e0\u0003\u01e0", + "\u0003\u01e0\u0003\u01e0\u0005\u01e0\u1ebc\n\u01e0\u0005\u01e0\u1ebe", + "\n\u01e0\u0003\u01e1\u0003\u01e1\u0005\u01e1\u1ec2\n\u01e1\u0003\u01e2", + "\u0003\u01e2\u0003\u01e2\u0003\u01e2\u0003\u01e2\u0003\u01e2\u0003\u01e2", + "\u0003\u01e2\u0005\u01e2\u1ecc\n\u01e2\u0003\u01e2\u0003\u01e2\u0003", + "\u01e2\u0003\u01e2\u0003\u01e2\u0003\u01e2\u0003\u01e2\u0003\u01e2\u0003", + "\u01e2\u0003\u01e2\u0003\u01e2\u0003\u01e2\u0003\u01e2\u0003\u01e2\u0005", + "\u01e2\u1edc\n\u01e2\u0005\u01e2\u1ede\n\u01e2\u0003\u01e2\u0003\u01e2", + "\u0003\u01e2\u0005\u01e2\u1ee3\n\u01e2\u0007\u01e2\u1ee5\n\u01e2\f\u01e2", + "\u000e\u01e2\u1ee8\u000b\u01e2\u0003\u01e3\u0003\u01e3\u0003\u01e3\u0005", + "\u01e3\u1eed\n\u01e3\u0003\u01e4\u0003\u01e4\u0003\u01e4\u0003\u01e5", + "\u0003\u01e5\u0005\u01e5\u1ef4\n\u01e5\u0003\u01e5\u0003\u01e5\u0003", + "\u01e6\u0003\u01e6\u0003\u01e6\u0007\u01e6\u1efb\n\u01e6\f\u01e6\u000e", + "\u01e6\u1efe\u000b\u01e6\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e7", + "\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e7\u0003\u01e8\u0003\u01e8", + "\u0003\u01e8\u0003\u01e8\u0005\u01e8\u1f0c\n\u01e8\u0003\u01e9\u0003", + "\u01e9\u0005\u01e9\u1f10\n\u01e9\u0003\u01ea\u0003\u01ea\u0003\u01ea", + "\u0003\u01ea\u0003\u01ea\u0005\u01ea\u1f17\n\u01ea\u0003\u01ea\u0005", + "\u01ea\u1f1a\n\u01ea\u0003\u01eb\u0003\u01eb\u0005\u01eb\u1f1e\n\u01eb", + "\u0003\u01ec\u0005\u01ec\u1f21\n\u01ec\u0003\u01ec\u0003\u01ec\u0003", + "\u01ec\u0003\u01ec\u0003\u01ec\u0003\u01ec\u0003\u01ec\u0003\u01ec\u0003", + "\u01ec\u0003\u01ec\u0003\u01ec\u0005\u01ec\u1f2e\n\u01ec\u0003\u01ed", + "\u0003\u01ed\u0005\u01ed\u1f32\n\u01ed\u0003\u01ee\u0003\u01ee\u0003", + "\u01ee\u0005\u01ee\u1f37\n\u01ee\u0003\u01ef\u0003\u01ef\u0003\u01ef", + "\u0003\u01ef\u0003\u01ef\u0003\u01ef\u0005\u01ef\u1f3f\n\u01ef\u0003", + "\u01f0\u0003\u01f0\u0005\u01f0\u1f43\n\u01f0\u0003\u01f1\u0003\u01f1", + "\u0005\u01f1\u1f47\n\u01f1\u0003\u01f2\u0003\u01f2\u0003\u01f2\u0003", + "\u01f2\u0003\u01f3\u0003\u01f3\u0003\u01f3\u0007\u01f3\u1f50\n\u01f3", + "\f\u01f3\u000e\u01f3\u1f53\u000b\u01f3\u0003\u01f4\u0003\u01f4\u0003", + "\u01f4\u0003\u01f4\u0005\u01f4\u1f59\n\u01f4\u0003\u01f4\u0003\u01f4", + "\u0003\u01f5\u0003\u01f5\u0005\u01f5\u1f5f\n\u01f5\u0003\u01f5\u0003", + "\u01f5\u0005\u01f5\u1f63\n\u01f5\u0005\u01f5\u1f65\n\u01f5\u0003\u01f6", + "\u0003\u01f6\u0005\u01f6\u1f69\n\u01f6\u0003\u01f7\u0003\u01f7\u0003", + "\u01f7\u0003\u01f7\u0005\u01f7\u1f6f\n\u01f7\u0003\u01f7\u0003\u01f7", + "\u0003\u01f7\u0003\u01f7\u0003\u01f7\u0003\u01f7\u0003\u01f7\u0005\u01f7", + "\u1f78\n\u01f7\u0003\u01f7\u0003\u01f7\u0003\u01f7\u0003\u01f7\u0005", + "\u01f7\u1f7e\n\u01f7\u0005\u01f7\u1f80\n\u01f7\u0005\u01f7\u1f82\n\u01f7", + "\u0003\u01f8\u0003\u01f8\u0003\u01f8\u0003\u01f8\u0003\u01f8\u0005\u01f8", + "\u1f89\n\u01f8\u0003\u01f9\u0003\u01f9\u0005\u01f9\u1f8d\n\u01f9\u0003", + "\u01fa\u0003\u01fa\u0003\u01fb\u0003\u01fb\u0003\u01fb\u0003\u01fb\u0003", + "\u01fb\u0005\u01fb\u1f96\n\u01fb\u0003\u01fc\u0003\u01fc\u0005\u01fc", + "\u1f9a\n\u01fc\u0003\u01fd\u0003\u01fd\u0003\u01fe\u0003\u01fe\u0003", + "\u01ff\u0003\u01ff\u0003\u01ff\u0003\u01ff\u0005\u01ff\u1fa4\n\u01ff", + "\u0003\u0200\u0003\u0200\u0003\u0200\u0007\u0200\u1fa9\n\u0200\f\u0200", + "\u000e\u0200\u1fac\u000b\u0200\u0003\u0201\u0003\u0201\u0003\u0201\u0003", + "\u0201\u0003\u0201\u0005\u0201\u1fb3\n\u0201\u0003\u0202\u0003\u0202", + "\u0003\u0202\u0003\u0203\u0003\u0203\u0003\u0203\u0003\u0203\u0003\u0203", + "\u0003\u0204\u0003\u0204\u0003\u0204\u0003\u0204\u0003\u0204\u0003\u0205", + "\u0003\u0205\u0003\u0205\u0003\u0205\u0003\u0205\u0003\u0205\u0003\u0206", + "\u0003\u0206\u0003\u0206\u0005\u0206\u1fcb\n\u0206\u0003\u0207\u0003", + "\u0207\u0003\u0207\u0003\u0207\u0005\u0207\u1fd1\n\u0207\u0003\u0208", + "\u0003\u0208\u0005\u0208\u1fd5\n\u0208\u0003\u0209\u0006\u0209\u1fd8", + "\n\u0209\r\u0209\u000e\u0209\u1fd9\u0003\u020a\u0003\u020a\u0003\u020a", + "\u0003\u020a\u0003\u020b\u0003\u020b\u0003\u020b\u0005\u020b\u1fe3\n", + "\u020b\u0003\u020b\u0003\u020b\u0005\u020b\u1fe7\n\u020b\u0003\u020b", + "\u0005\u020b\u1fea\n\u020b\u0003\u020c\u0003\u020c\u0003\u020c\u0005", + "\u020c\u1fef\n\u020c\u0003\u020d\u0003\u020d\u0003\u020d\u0003\u020d", + "\u0003\u020d\u0003\u020d\u0003\u020d\u0003\u020d\u0003\u020d\u0007\u020d", + "\u1ffa\n\u020d\f\u020d\u000e\u020d\u1ffd\u000b\u020d\u0003\u020e\u0003", + "\u020e\u0003\u020e\u0005\u020e\u2002\n\u020e\u0003\u020f\u0003\u020f", + "\u0003\u020f\u0007\u020f\u2007\n\u020f\f\u020f\u000e\u020f\u200a\u000b", + "\u020f\u0003\u0210\u0003\u0210\u0003\u0210\u0005\u0210\u200f\n\u0210", + "\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210", + "\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210", + "\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210", + "\u0003\u0210\u0005\u0210\u2024\n\u0210\u0003\u0210\u0003\u0210\u0003", + "\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0005\u0210\u202d", + "\n\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0005\u0210\u2032\n\u0210", + "\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0005\u0210\u2038\n", + "\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0005\u0210\u203d\n\u0210", + "\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0005\u0210", + "\u2044\n\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0005\u0210\u2049", + "\n\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0003\u0210\u0007\u0210", + "\u204f\n\u0210\f\u0210\u000e\u0210\u2052\u000b\u0210\u0003\u0211\u0005", + "\u0211\u2055\n\u0211\u0003\u0211\u0003\u0211\u0003\u0211\u0003\u0211", + "\u0003\u0211\u0005\u0211\u205c\n\u0211\u0003\u0212\u0003\u0212\u0005", + "\u0212\u2060\n\u0212\u0003\u0213\u0003\u0213\u0003\u0213\u0005\u0213", + "\u2065\n\u0213\u0003\u0213\u0005\u0213\u2068\n\u0213\u0003\u0213\u0003", + "\u0213\u0003\u0213\u0003\u0213\u0003\u0213\u0005\u0213\u206f\n\u0213", + "\u0003\u0214\u0003\u0214\u0005\u0214\u2073\n\u0214\u0003\u0215\u0003", + "\u0215\u0003\u0215\u0003\u0215\u0003\u0215\u0003\u0215\u0003\u0215\u0005", + "\u0215\u207c\n\u0215\u0003\u0216\u0003\u0216\u0005\u0216\u2080\n\u0216", + "\u0003\u0216\u0003\u0216\u0003\u0216\u0003\u0216\u0003\u0216\u0003\u0216", + "\u0005\u0216\u2088\n\u0216\u0005\u0216\u208a\n\u0216\u0003\u0217\u0003", + "\u0217\u0003\u0217\u0007\u0217\u208f\n\u0217\f\u0217\u000e\u0217\u2092", + "\u000b\u0217\u0003\u0218\u0003\u0218\u0005\u0218\u2096\n\u0218\u0003", + "\u0218\u0005\u0218\u2099\n\u0218\u0003\u0219\u0003\u0219\u0003\u0219", + "\u0003\u0219\u0003\u0219\u0003\u0219\u0003\u0219\u0003\u021a\u0003\u021a", + "\u0003\u021a\u0003\u021a\u0003\u021a\u0003\u021a\u0005\u021a\u20a8\n", + "\u021a\u0003\u021b\u0003\u021b\u0003\u021b\u0003\u021b\u0003\u021b\u0003", + "\u021b\u0003\u021b\u0003\u021b\u0003\u021b\u0003\u021b\u0005\u021b\u20b4", + "\n\u021b\u0003\u021c\u0003\u021c\u0003\u021c\u0003\u021d\u0003\u021d", + "\u0003\u021d\u0007\u021d\u20bc\n\u021d\f\u021d\u000e\u021d\u20bf\u000b", + "\u021d\u0003\u021e\u0003\u021e\u0003\u021e\u0003\u021e\u0003\u021e\u0003", + "\u021e\u0005\u021e\u20c7\n\u021e\u0003\u021f\u0003\u021f\u0003\u021f", + "\u0005\u021f\u20cc\n\u021f\u0003\u0220\u0003\u0220\u0003\u0220\u0005", + "\u0220\u20d1\n\u0220\u0003\u0221\u0003\u0221\u0003\u0221\u0003\u0221", + "\u0003\u0221\u0005\u0221\u20d8\n\u0221\u0003\u0221\u0005\u0221\u20db", + "\n\u0221\u0003\u0222\u0003\u0222\u0005\u0222\u20df\n\u0222\u0003\u0223", + "\u0003\u0223\u0003\u0223\u0007\u0223\u20e4\n\u0223\f\u0223\u000e\u0223", + "\u20e7\u000b\u0223\u0003\u0224\u0003\u0224\u0003\u0224\u0003\u0224\u0003", + "\u0225\u0003\u0225\u0003\u0225\u0003\u0225\u0003\u0225\u0003\u0225\u0003", + "\u0225\u0003\u0225\u0003\u0225\u0003\u0225\u0003\u0225\u0003\u0225\u0003", + "\u0225\u0003\u0225\u0003\u0225\u0003\u0225\u0003\u0225\u0005\u0225\u20fe", + "\n\u0225\u0003\u0225\u0003\u0225\u0003\u0226\u0003\u0226\u0003\u0226", + "\u0007\u0226\u2105\n\u0226\f\u0226\u000e\u0226\u2108\u000b\u0226\u0003", + "\u0227\u0003\u0227\u0003\u0227\u0005\u0227\u210d\n\u0227\u0003\u0227", + "\u0003\u0227\u0005\u0227\u2111\n\u0227\u0003\u0228\u0006\u0228\u2114", + "\n\u0228\r\u0228\u000e\u0228\u2115\u0003\u0229\u0003\u0229\u0003\u0229", + "\u0003\u0229\u0003\u0229\u0003\u0229\u0003\u0229\u0003\u0229\u0005\u0229", + "\u2120\n\u0229\u0003\u022a\u0003\u022a\u0003\u022a\u0007\u022a\u2125", + "\n\u022a\f\u022a\u000e\u022a\u2128\u000b\u022a\u0003\u022b\u0003\u022b", + "\u0003\u022b\u0003\u022b\u0003\u022b\u0003\u022b\u0005\u022b\u2130\n", + "\u022b\u0003\u022c\u0005\u022c\u2133\n\u022c\u0003\u022c\u0003\u022c", + "\u0003\u022c\u0003\u022c\u0003\u022c\u0003\u022c\u0003\u022c\u0005\u022c", + "\u213c\n\u022c\u0005\u022c\u213e\n\u022c\u0003\u022c\u0003\u022c\u0003", + "\u022c\u0003\u022c\u0005\u022c\u2144\n\u022c\u0003\u022d\u0003\u022d", + "\u0005\u022d\u2148\n\u022d\u0003\u022d\u0007\u022d\u214b\n\u022d\f\u022d", + "\u000e\u022d\u214e\u000b\u022d\u0003\u022e\u0003\u022e\u0003\u022e\u0003", + "\u022e\u0003\u022e\u0003\u022e\u0003\u022e\u0003\u022e\u0003\u022e\u0003", + "\u022e\u0003\u022e\u0005\u022e\u215b\n\u022e\u0005\u022e\u215d\n\u022e", + "\u0003\u022f\u0003\u022f\u0003\u022f\u0003\u022f\u0005\u022f\u2163\n", + "\u022f\u0003\u0230\u0003\u0230\u0005\u0230\u2167\n\u0230\u0003\u0230", + "\u0003\u0230\u0003\u0231\u0003\u0231\u0003\u0231\u0003\u0231\u0003\u0231", + "\u0005\u0231\u2170\n\u0231\u0003\u0232\u0003\u0232\u0003\u0232\u0003", + "\u0232\u0003\u0232\u0003\u0232\u0003\u0232\u0003\u0232\u0003\u0232\u0003", + "\u0232\u0003\u0232\u0003\u0232\u0003\u0232\u0003\u0232\u0003\u0232\u0003", + "\u0232\u0005\u0232\u2182\n\u0232\u0003\u0233\u0003\u0233\u0003\u0233", + "\u0003\u0233\u0003\u0233\u0005\u0233\u2189\n\u0233\u0003\u0234\u0003", + "\u0234\u0005\u0234\u218d\n\u0234\u0003\u0235\u0003\u0235\u0005\u0235", + "\u2191\n\u0235\u0003\u0236\u0003\u0236\u0003\u0236\u0003\u0236\u0003", + "\u0236\u0003\u0236\u0003\u0237\u0003\u0237\u0003\u0237\u0003\u0238\u0003", + "\u0238\u0003\u0238\u0003\u0238\u0003\u0238\u0005\u0238\u21a1\n\u0238", + "\u0003\u0239\u0003\u0239\u0003\u0239\u0003\u0239\u0003\u0239\u0005\u0239", + "\u21a8\n\u0239\u0003\u023a\u0003\u023a\u0003\u023a\u0003\u023a\u0003", + "\u023a\u0003\u023a\u0005\u023a\u21b0\n\u023a\u0003\u023b\u0003\u023b", + "\u0005\u023b\u21b4\n\u023b\u0003\u023c\u0003\u023c\u0003\u023c\u0003", + "\u023c\u0003\u023c\u0005\u023c\u21bb\n\u023c\u0003\u023c\u0003\u023c", + "\u0003\u023d\u0003\u023d\u0003\u023e\u0003\u023e\u0003\u023e\u0003\u023e", + "\u0003\u023e\u0003\u023e\u0003\u023e\u0005\u023e\u21c8\n\u023e\u0003", + "\u023f\u0003\u023f\u0003\u023f\u0003\u023f\u0003\u023f\u0003\u023f\u0003", + "\u023f\u0003\u023f\u0003\u023f\u0003\u023f\u0003\u023f\u0003\u023f\u0003", + "\u023f\u0003\u023f\u0005\u023f\u21d8\n\u023f\u0003\u023f\u0003\u023f", + "\u0003\u023f\u0003\u023f\u0005\u023f\u21de\n\u023f\u0003\u023f\u0003", + "\u023f\u0003\u023f\u0003\u023f\u0005\u023f\u21e4\n\u023f\u0003\u0240", + "\u0003\u0240\u0003\u0240\u0003\u0240\u0003\u0240\u0005\u0240\u21eb\n", + "\u0240\u0003\u0241\u0003\u0241\u0003\u0241\u0005\u0241\u21f0\n\u0241", + "\u0003\u0242\u0003\u0242\u0003\u0243\u0003\u0243\u0005\u0243\u21f6\n", + "\u0243\u0003\u0244\u0003\u0244\u0003\u0244\u0007\u0244\u21fb\n\u0244", + "\f\u0244\u000e\u0244\u21fe\u000b\u0244\u0003\u0245\u0003\u0245\u0003", + "\u0245\u0007\u0245\u2203\n\u0245\f\u0245\u000e\u0245\u2206\u000b\u0245", + "\u0003\u0246\u0003\u0246\u0003\u0246\u0007\u0246\u220b\n\u0246\f\u0246", + "\u000e\u0246\u220e\u000b\u0246\u0003\u0247\u0003\u0247\u0005\u0247\u2212", + "\n\u0247\u0003\u0247\u0003\u0247\u0005\u0247\u2216\n\u0247\u0003\u0248", + "\u0005\u0248\u2219\n\u0248\u0003\u0248\u0003\u0248\u0003\u0249\u0003", + "\u0249\u0005\u0249\u221f\n\u0249\u0003\u024a\u0003\u024a\u0003\u024a", + "\u0005\u024a\u2224\n\u024a\u0003\u024a\u0003\u024a\u0003\u024a\u0003", + "\u024a\u0003\u024a\u0003\u024a\u0003\u024a\u0003\u024a\u0003\u024a\u0003", + "\u024a\u0003\u024a\u0003\u024a\u0003\u024a\u0003\u024a\u0005\u024a\u2234", + "\n\u024a\u0003\u024a\u0005\u024a\u2237\n\u024a\u0005\u024a\u2239\n\u024a", + "\u0003\u024b\u0003\u024b\u0003\u024b\u0003\u024b\u0003\u024b\u0003\u024b", + "\u0003\u024b\u0003\u024b\u0003\u024b\u0003\u024b\u0005\u024b\u2245\n", + "\u024b\u0005\u024b\u2247\n\u024b\u0003\u024c\u0003\u024c\u0005\u024c", + "\u224b\n\u024c\u0003\u024c\u0003\u024c\u0003\u024c\u0003\u024c\u0003", + "\u024c\u0003\u024c\u0005\u024c\u2253\n\u024c\u0005\u024c\u2255\n\u024c", + "\u0003\u024c\u0003\u024c\u0003\u024c\u0005\u024c\u225a\n\u024c\u0003", + "\u024d\u0003\u024d\u0003\u024d\u0003\u024d\u0007\u024d\u2260\n\u024d", + "\f\u024d\u000e\u024d\u2263\u000b\u024d\u0003\u024e\u0005\u024e\u2266", + "\n\u024e\u0003\u024e\u0003\u024e\u0003\u024f\u0003\u024f\u0003\u024f", + "\u0007\u024f\u226d\n\u024f\f\u024f\u000e\u024f\u2270\u000b\u024f\u0003", + "\u0250\u0003\u0250\u0003\u0250\u0007\u0250\u2275\n\u0250\f\u0250\u000e", + "\u0250\u2278\u000b\u0250\u0003\u0251\u0003\u0251\u0003\u0251\u0005\u0251", + "\u227d\n\u0251\u0003\u0252\u0005\u0252\u2280\n\u0252\u0003\u0252\u0003", + "\u0252\u0003\u0253\u0003\u0253\u0003\u0253\u0003\u0253\u0003\u0253\u0005", + "\u0253\u2289\n\u0253\u0003\u0254\u0003\u0254\u0003\u0254\u0005\u0254", + "\u228e\n\u0254\u0003\u0255\u0003\u0255\u0003\u0255\u0007\u0255\u2293", + "\n\u0255\f\u0255\u000e\u0255\u2296\u000b\u0255\u0003\u0256\u0003\u0256", + "\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0005\u0256", + "\u229f\n\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003", + "\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003", + "\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003", + "\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003", + "\u0256\u0003\u0256\u0005\u0256\u22b9\n\u0256\u0003\u0256\u0003\u0256", + "\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256\u0003\u0256", + "\u0003\u0256\u0005\u0256\u22c4\n\u0256\u0007\u0256\u22c6\n\u0256\f\u0256", + "\u000e\u0256\u22c9\u000b\u0256\u0003\u0257\u0003\u0257\u0003\u0257\u0003", + "\u0257\u0003\u0257\u0005\u0257\u22d0\n\u0257\u0003\u0257\u0003\u0257", + "\u0003\u0257\u0003\u0257\u0003\u0257\u0003\u0257\u0003\u0257\u0003\u0257", + "\u0003\u0257\u0003\u0257\u0003\u0257\u0003\u0257\u0003\u0257\u0003\u0257", + "\u0003\u0257\u0003\u0257\u0003\u0257\u0003\u0257\u0003\u0257\u0003\u0257", + "\u0003\u0257\u0005\u0257\u22e7\n\u0257\u0003\u0257\u0003\u0257\u0003", + "\u0257\u0003\u0257\u0003\u0257\u0003\u0257\u0005\u0257\u22ef\n\u0257", + "\u0003\u0258\u0003\u0258\u0003\u0259\u0003\u0259\u0003\u0259\u0003\u0259", + "\u0003\u0259\u0003\u0259\u0005\u0259\u22f9\n\u0259\u0003\u0259\u0003", + "\u0259\u0003\u0259\u0003\u0259\u0003\u0259\u0003\u0259\u0003\u0259\u0003", + "\u0259\u0003\u0259\u0003\u0259\u0003\u0259\u0003\u0259\u0005\u0259\u2307", + "\n\u0259\u0003\u0259\u0003\u0259\u0003\u025a\u0003\u025a\u0003\u025a", + "\u0003\u025a\u0003\u025a\u0003\u025a\u0005\u025a\u2311\n\u025a\u0003", + "\u025b\u0003\u025b\u0005\u025b\u2315\n\u025b\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0005\u025c\u2323\n", + "\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0005", + "\u025c\u232a\n\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0005\u025c\u2331\n\u025c\u0003\u025c\u0003\u025c\u0003", + "\u025c\u0003\u025c\u0003\u025c\u0005\u025c\u2338\n\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0005\u025c\u2351\n", + "\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003", + "\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003", + "\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003", + "\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003", + "\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0005\u025c\u236e\n\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0005\u025c\u2395\n\u025c\u0005\u025c\u2397\n\u025c\u0003", + "\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003", + "\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003", + "\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003", + "\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003", + "\u025c\u0003\u025c\u0005\u025c\u23b3\n\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c", + "\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0003\u025c\u0005\u025c", + "\u23c8\n\u025c\u0003\u025d\u0003\u025d\u0003\u025d\u0003\u025d\u0003", + "\u025d\u0005\u025d\u23cf\n\u025d\u0003\u025e\u0003\u025e\u0003\u025e", + "\u0003\u025e\u0003\u025e\u0003\u025e\u0003\u025e\u0003\u025e\u0003\u025e", + "\u0003\u025e\u0003\u025e\u0005\u025e\u23dc\n\u025e\u0003\u025f\u0003", + "\u025f\u0003\u025f\u0003\u025f\u0003\u025f\u0003\u0260\u0003\u0260\u0003", + "\u0260\u0007\u0260\u23e6\n\u0260\f\u0260\u000e\u0260\u23e9\u000b\u0260", + "\u0003\u0261\u0003\u0261\u0003\u0261\u0005\u0261\u23ee\n\u0261\u0003", + "\u0262\u0003\u0262\u0003\u0263\u0003\u0263\u0003\u0263\u0003\u0263\u0003", + "\u0263\u0005\u0263\u23f7\n\u0263\u0003\u0264\u0003\u0264\u0003\u0264", + "\u0003\u0264\u0003\u0264\u0003\u0264\u0003\u0264\u0003\u0264\u0003\u0264", + "\u0003\u0264\u0003\u0264\u0003\u0264\u0003\u0264\u0003\u0264\u0003\u0264", + "\u0005\u0264\u2408\n\u0264\u0003\u0265\u0003\u0265\u0003\u0265\u0003", + "\u0266\u0003\u0266\u0003\u0266\u0003\u0266\u0003\u0266\u0003\u0266\u0003", + "\u0266\u0005\u0266\u2414\n\u0266\u0003\u0267\u0003\u0267\u0003\u0267", + "\u0003\u0267\u0003\u0267\u0003\u0267\u0003\u0267\u0005\u0267\u241d\n", + "\u0267\u0003\u0268\u0003\u0268\u0003\u0268\u0005\u0268\u2422\n\u0268", + "\u0003\u0269\u0003\u0269\u0003\u0269\u0007\u0269\u2427\n\u0269\f\u0269", + "\u000e\u0269\u242a\u000b\u0269\u0003\u026a\u0003\u026a\u0003\u026a\u0003", + "\u026a\u0003\u026b\u0003\u026b\u0003\u026b\u0005\u026b\u2433\n\u026b", + "\u0003\u026b\u0005\u026b\u2436\n\u026b\u0003\u026c\u0003\u026c\u0003", + "\u026c\u0003\u026c\u0003\u026c\u0003\u026c\u0003\u026c\u0003\u026d\u0003", + "\u026d\u0005\u026d\u2441\n\u026d\u0003\u026e\u0003\u026e\u0003\u026e", + "\u0003\u026e\u0005\u026e\u2447\n\u026e\u0003\u026f\u0003\u026f\u0003", + "\u026f\u0003\u026f\u0003\u026f\u0003\u026f\u0003\u026f\u0003\u026f\u0003", + "\u026f\u0003\u026f\u0003\u026f\u0003\u026f\u0003\u026f\u0005\u026f\u2456", + "\n\u026f\u0003\u0270\u0003\u0270\u0003\u0270\u0003\u0270\u0003\u0270", + "\u0003\u0270\u0005\u0270\u245e\n\u0270\u0003\u0271\u0003\u0271\u0003", + "\u0271\u0003\u0271\u0003\u0271\u0003\u0271\u0003\u0271\u0005\u0271\u2467", + "\n\u0271\u0003\u0272\u0003\u0272\u0003\u0272\u0003\u0272\u0003\u0272", + "\u0003\u0272\u0003\u0272\u0005\u0272\u2470\n\u0272\u0003\u0272\u0005", + "\u0272\u2473\n\u0272\u0003\u0273\u0003\u0273\u0003\u0273\u0005\u0273", + "\u2478\n\u0273\u0003\u0273\u0003\u0273\u0003\u0273\u0003\u0273\u0003", + "\u0273\u0003\u0273\u0003\u0273\u0005\u0273\u2481\n\u0273\u0003\u0274", + "\u0003\u0274\u0003\u0274\u0005\u0274\u2486\n\u0274\u0003\u0274\u0003", + "\u0274\u0003\u0275\u0003\u0275\u0003\u0275\u0003\u0275\u0003\u0275\u0003", + "\u0275\u0003\u0276\u0003\u0276\u0003\u0277\u0003\u0277\u0005\u0277\u2494", + "\n\u0277\u0003\u0278\u0003\u0278\u0003\u0279\u0003\u0279\u0003\u0279", + "\u0003\u0279\u0003\u0279\u0003\u0279\u0005\u0279\u249e\n\u0279\u0003", + "\u027a\u0003\u027a\u0003\u027a\u0003\u027a\u0003\u027a\u0003\u027a\u0005", + "\u027a\u24a6\n\u027a\u0003\u027b\u0003\u027b\u0003\u027b\u0003\u027b", + "\u0003\u027b\u0003\u027b\u0003\u027b\u0003\u027b\u0003\u027b\u0003\u027b", + "\u0003\u027b\u0003\u027b\u0005\u027b\u24b4\n\u027b\u0003\u027c\u0003", + "\u027c\u0003\u027c\u0007\u027c\u24b9\n\u027c\f\u027c\u000e\u027c\u24bc", + "\u000b\u027c\u0003\u027d\u0003\u027d\u0003\u027d\u0007\u027d\u24c1\n", + "\u027d\f\u027d\u000e\u027d\u24c4\u000b\u027d\u0003\u027e\u0003\u027e", + "\u0003\u027e\u0003\u027e\u0003\u027e\u0005\u027e\u24cb\n\u027e\u0003", + "\u027f\u0003\u027f\u0003\u027f\u0007\u027f\u24d0\n\u027f\f\u027f\u000e", + "\u027f\u24d3\u000b\u027f\u0003\u0280\u0003\u0280\u0003\u0280\u0005\u0280", + "\u24d8\n\u0280\u0003\u0280\u0003\u0280\u0003\u0281\u0003\u0281\u0003", + "\u0281\u0007\u0281\u24df\n\u0281\f\u0281\u000e\u0281\u24e2\u000b\u0281", + "\u0003\u0282\u0003\u0282\u0003\u0282\u0003\u0282\u0003\u0282\u0005\u0282", + "\u24e9\n\u0282\u0003\u0283\u0003\u0283\u0003\u0283\u0003\u0283\u0003", + "\u0283\u0003\u0283\u0003\u0283\u0003\u0283\u0005\u0283\u24f3\n\u0283", + "\u0003\u0284\u0003\u0284\u0003\u0285\u0003\u0285\u0003\u0285\u0003\u0285", + "\u0003\u0285\u0003\u0285\u0003\u0285\u0005\u0285\u24fe\n\u0285\u0003", + "\u0286\u0003\u0286\u0003\u0286\u0003\u0286\u0003\u0286\u0005\u0286\u2505", + "\n\u0286\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287", + "\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287", + "\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287", + "\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287", + "\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287\u0003\u0287\u0005\u0287", + "\u2523\n\u0287\u0003\u0288\u0003\u0288\u0003\u0288\u0003\u0288\u0003", + "\u0288\u0003\u0288\u0003\u0288\u0005\u0288\u252c\n\u0288\u0003\u0289", + "\u0003\u0289\u0003\u0289\u0003\u0289\u0003\u0289\u0005\u0289\u2533\n", + "\u0289\u0003\u028a\u0003\u028a\u0003\u028a\u0003\u028a\u0003\u028a\u0003", + "\u028a\u0003\u028b\u0006\u028b\u253c\n\u028b\r\u028b\u000e\u028b\u253d", + "\u0003\u028c\u0003\u028c\u0003\u028c\u0003\u028c\u0003\u028c\u0003\u028d", + "\u0003\u028d\u0003\u028d\u0005\u028d\u2548\n\u028d\u0003\u028e\u0003", + "\u028e\u0005\u028e\u254c\n\u028e\u0003\u028f\u0003\u028f\u0005\u028f", + "\u2550\n\u028f\u0003\u0290\u0003\u0290\u0003\u0290\u0005\u0290\u2555", + "\n\u0290\u0003\u0290\u0003\u0290\u0003\u0290\u0003\u0290\u0003\u0290", + "\u0003\u0290\u0005\u0290\u255d\n\u0290\u0003\u0290\u0003\u0290\u0005", + "\u0290\u2561\n\u0290\u0003\u0291\u0003\u0291\u0005\u0291\u2565\n\u0291", + "\u0003\u0292\u0006\u0292\u2568\n\u0292\r\u0292\u000e\u0292\u2569\u0003", + "\u0293\u0007\u0293\u256d\n\u0293\f\u0293\u000e\u0293\u2570\u000b\u0293", + "\u0003\u0294\u0003\u0294\u0005\u0294\u2574\n\u0294\u0003\u0295\u0003", + "\u0295\u0003\u0295\u0007\u0295\u2579\n\u0295\f\u0295\u000e\u0295\u257c", + "\u000b\u0295\u0003\u0296\u0003\u0296\u0003\u0296\u0003\u0296\u0003\u0296", + "\u0005\u0296\u2583\n\u0296\u0003\u0296\u0005\u0296\u2586\n\u0296\u0003", + "\u0297\u0003\u0297\u0003\u0297\u0007\u0297\u258b\n\u0297\f\u0297\u000e", + "\u0297\u258e\u000b\u0297\u0003\u0298\u0003\u0298\u0005\u0298\u2592\n", + "\u0298\u0003\u0299\u0003\u0299\u0003\u0299\u0007\u0299\u2597\n\u0299", + "\f\u0299\u000e\u0299\u259a\u000b\u0299\u0003\u029a\u0003\u029a\u0003", + "\u029b\u0003\u029b\u0003\u029c\u0003\u029c\u0003\u029d\u0003\u029d\u0003", + "\u029d\u0003\u029d\u0005\u029d\u25a6\n\u029d\u0003\u029e\u0003\u029e", + "\u0003\u029e\u0003\u029e\u0003\u029e\u0003\u029e\u0003\u029e\u0003\u029e", + "\u0003\u029e\u0003\u029e\u0003\u029e\u0003\u029e\u0003\u029e\u0005\u029e", + "\u25b5\n\u029e\u0003\u029e\u0003\u029e\u0003\u029e\u0003\u029e\u0003", + "\u029e\u0003\u029e\u0003\u029e\u0003\u029e\u0003\u029e\u0003\u029e\u0003", + "\u029e\u0003\u029e\u0005\u029e\u25c3\n\u029e\u0003\u029e\u0003\u029e", + "\u0003\u029e\u0005\u029e\u25c8\n\u029e\u0003\u029f\u0003\u029f\u0003", + "\u02a0\u0003\u02a0\u0003\u02a1\u0003\u02a1\u0003\u02a2\u0003\u02a2\u0003", + "\u02a3\u0003\u02a3\u0003\u02a3\u0003\u02a4\u0003\u02a4\u0003\u02a4\u0003", + "\u02a4\u0007\u02a4\u25d9\n\u02a4\f\u02a4\u000e\u02a4\u25dc\u000b\u02a4", + "\u0003\u02a4\u0003\u02a4\u0005\u02a4\u25e0\n\u02a4\u0003\u02a5\u0003", + "\u02a5\u0003\u02a5\u0005\u02a5\u25e5\n\u02a5\u0003\u02a6\u0003\u02a6", + "\u0003\u02a6\u0003\u02a6\u0003\u02a6\u0005\u02a6\u25ec\n\u02a6\u0003", + "\u02a7\u0003\u02a7\u0003\u02a8\u0003\u02a8\u0003\u02a8\u0005\u02a8\u25f3", + "\n\u02a8\u0003\u02a9\u0003\u02a9\u0003\u02a9\u0007\u02a9\u25f8\n\u02a9", + "\f\u02a9\u000e\u02a9\u25fb\u000b\u02a9\u0003\u02aa\u0003\u02aa\u0003", + "\u02aa\u0003\u02aa\u0005\u02aa\u2601\n\u02aa\u0003\u02ab\u0003\u02ab", + "\u0003\u02ab\u0003\u02ab\u0005\u02ab\u2607\n\u02ab\u0003\u02ac\u0003", + "\u02ac\u0003\u02ac\u0003\u02ac\u0005\u02ac\u260d\n\u02ac\u0003\u02ad", + "\u0003\u02ad\u0003\u02ad\u0003\u02ad\u0003\u02ad\u0003\u02ad\u0005\u02ad", + "\u2615\n\u02ad\u0003\u02ae\u0003\u02ae\u0003\u02ae\u0003\u02ae\u0003", + "\u02ae\u0003\u02ae\u0003\u02ae\u0005\u02ae\u261e\n\u02ae\u0003\u02af", + "\u0003\u02af\u0003\u02b0\u0003\u02b0\u0003\u02b1\u0003\u02b1\u0003\u02b1", + "\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1", + "\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1", + "\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1", + "\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1", + "\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1", + "\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1", + "\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1", + "\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1\u0003\u02b1", + "\u0005\u02b1\u2657\n\u02b1\u0003\u02b2\u0003\u02b2\u0003\u02b3\u0003", + "\u02b3\u0003\u02b4\u0003\u02b4\u0003\u02b4\u0003\u02b4\u0003\u02b5\u0007", + "\u02b5\u2662\n\u02b5\f\u02b5\u000e\u02b5\u2665\u000b\u02b5\u0003\u02b6", + "\u0003\u02b6\u0003\u02b6\u0003\u02b6\u0003\u02b6\u0003\u02b6\u0003\u02b6", + "\u0003\u02b6\u0003\u02b6\u0003\u02b6\u0003\u02b6\u0003\u02b6\u0003\u02b6", + "\u0003\u02b6\u0003\u02b6\u0003\u02b6\u0003\u02b6\u0003\u02b6\u0003\u02b6", + "\u0003\u02b6\u0005\u02b6\u267b\n\u02b6\u0003\u02b7\u0003\u02b7\u0003", + "\u02b8\u0003\u02b8\u0003\u02b8\u0003\u02b8\u0005\u02b8\u2683\n\u02b8", + "\u0003\u02b9\u0003\u02b9\u0005\u02b9\u2687\n\u02b9\u0003\u02ba\u0003", + "\u02ba\u0003\u02ba\u0003\u02ba\u0003\u02ba\u0003\u02ba\u0003\u02ba\u0003", + "\u02bb\u0003\u02bb\u0003\u02bb\u0005\u02bb\u2693\n\u02bb\u0005\u02bb", + "\u2695\n\u02bb\u0003\u02bc\u0003\u02bc\u0003\u02bd\u0006\u02bd\u269a", + "\n\u02bd\r\u02bd\u000e\u02bd\u269b\u0003\u02be\u0003\u02be\u0003\u02be", + "\u0003\u02be\u0003\u02bf\u0003\u02bf\u0003\u02bf\u0005\u02bf\u26a5\n", + "\u02bf\u0003\u02c0\u0003\u02c0\u0003\u02c0\u0003\u02c0\u0003\u02c0\u0003", + "\u02c0\u0003\u02c0\u0003\u02c0\u0003\u02c0\u0003\u02c0\u0003\u02c0\u0003", + "\u02c0\u0003\u02c0\u0003\u02c0\u0003\u02c0\u0003\u02c0\u0005\u02c0\u26b7", + "\n\u02c0\u0003\u02c0\u0003\u02c0\u0003\u02c1\u0003\u02c1\u0003\u02c1", + "\u0003\u02c1\u0005\u02c1\u26bf\n\u02c1\u0003\u02c2\u0003\u02c2\u0003", + "\u02c3\u0003\u02c3\u0003\u02c3\u0003\u02c3\u0003\u02c3\u0005\u02c3\u26c8", + "\n\u02c3\u0003\u02c4\u0003\u02c4\u0003\u02c4\u0007\u02c4\u26cd\n\u02c4", + "\f\u02c4\u000e\u02c4\u26d0\u000b\u02c4\u0003\u02c5\u0003\u02c5\u0003", + "\u02c5\u0003\u02c6\u0003\u02c6\u0003\u02c7\u0003\u02c7\u0005\u02c7\u26d9", + "\n\u02c7\u0003\u02c8\u0003\u02c8\u0003\u02c9\u0003\u02c9\u0005\u02c9", + "\u26df\n\u02c9\u0003\u02ca\u0003\u02ca\u0003\u02cb\u0003\u02cb\u0003", + "\u02cb\u0005\u02cb\u26e6\n\u02cb\u0003\u02cc\u0003\u02cc\u0003\u02cc", + "\u0005\u02cc\u26eb\n\u02cc\u0003\u02cd\u0003\u02cd\u0003\u02cd\u0003", + "\u02cd\u0005\u02cd\u26f1\n\u02cd\u0003\u02ce\u0003\u02ce\u0005\u02ce", + "\u26f5\n\u02ce\u0003\u02cf\u0003\u02cf\u0003\u02d0\u0007\u02d0\u26fa", + "\n\u02d0\f\u02d0\u000e\u02d0\u26fd\u000b\u02d0\u0003\u02d1\u0003\u02d1", + "\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1", + "\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1", + "\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1", + "\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1\u0003\u02d1", + "\u0003\u02d1\u0005\u02d1\u271a\n\u02d1\u0003\u02d2\u0003\u02d2\u0003", + "\u02d2\u0003\u02d2\u0003\u02d3\u0003\u02d3\u0003\u02d3\u0003\u02d3\u0003", + "\u02d3\u0003\u02d3\u0003\u02d3\u0003\u02d3\u0003\u02d3\u0003\u02d3\u0003", + "\u02d3\u0003\u02d3\u0003\u02d3\u0003\u02d3\u0005\u02d3\u272e\n\u02d3", + "\u0003\u02d4\u0003\u02d4\u0005\u02d4\u2732\n\u02d4\u0003\u02d5\u0003", + "\u02d5\u0003\u02d5\u0003\u02d5\u0003\u02d5\u0003\u02d6\u0003\u02d6\u0003", + "\u02d6\u0003\u02d6\u0003\u02d6\u0003\u02d6\u0003\u02d7\u0003\u02d7\u0003", + "\u02d7\u0005\u02d7\u2742\n\u02d7\u0003\u02d8\u0003\u02d8\u0003\u02d8", + "\u0007\u02d8\u2747\n\u02d8\f\u02d8\u000e\u02d8\u274a\u000b\u02d8\u0003", + "\u02d9\u0003\u02d9\u0003\u02d9\u0003\u02d9\u0003\u02da\u0003\u02da\u0003", + "\u02db\u0003\u02db\u0003\u02dc\u0003\u02dc\u0005\u02dc\u2756\n\u02dc", + "\u0003\u02dc\u0003\u02dc\u0003\u02dc\u0003\u02dc\u0007\u02dc\u275c\n", + "\u02dc\f\u02dc\u000e\u02dc\u275f\u000b\u02dc\u0003\u02dd\u0003\u02dd", + "\u0003\u02dd\u0003\u02dd\u0003\u02dd\u0003\u02dd\u0003\u02dd\u0003\u02dd", + "\u0003\u02dd\u0003\u02dd\u0003\u02de\u0003\u02de\u0003\u02de\u0003\u02de", + "\u0003\u02de\u0007\u02de\u2770\n\u02de\f\u02de\u000e\u02de\u2773\u000b", + "\u02de\u0003\u02df\u0003\u02df\u0003\u02df\u0005\u02df\u2778\n\u02df", + "\u0003\u02e0\u0003\u02e0\u0003\u02e0\u0003\u02e0\u0003\u02e0\u0003\u02e0", + "\u0003\u02e0\u0003\u02e0\u0003\u02e1\u0003\u02e1\u0005\u02e1\u2784\n", + "\u02e1\u0003\u02e2\u0006\u02e2\u2787\n\u02e2\r\u02e2\u000e\u02e2\u2788", + "\u0003\u02e3\u0003\u02e3\u0003\u02e3\u0003\u02e3\u0003\u02e3\u0003\u02e4", + "\u0003\u02e4\u0003\u02e4\u0005\u02e4\u2793\n\u02e4\u0003\u02e5\u0003", + "\u02e5\u0003\u02e5\u0003\u02e6\u0003\u02e6\u0003\u02e6\u0003\u02e6\u0003", + "\u02e6\u0003\u02e7\u0003\u02e7\u0003\u02e7\u0003\u02e7\u0003\u02e7\u0003", + "\u02e8\u0003\u02e8\u0003\u02e8\u0003\u02e8\u0003\u02e8\u0003\u02e8\u0003", + "\u02e8\u0003\u02e8\u0003\u02e8\u0003\u02e8\u0003\u02e8\u0003\u02e8\u0003", + "\u02e8\u0003\u02e8\u0003\u02e8\u0003\u02e8\u0003\u02e8\u0005\u02e8\u27b3", + "\n\u02e8\u0003\u02e9\u0003\u02e9\u0003\u02e9\u0005\u02e9\u27b8\n\u02e9", + "\u0003\u02ea\u0003\u02ea\u0003\u02ea\u0003\u02ea\u0003\u02ea\u0007\u02ea", + "\u27bf\n\u02ea\f\u02ea\u000e\u02ea\u27c2\u000b\u02ea\u0003\u02ea\u0003", + "\u02ea\u0005\u02ea\u27c6\n\u02ea\u0003\u02eb\u0003\u02eb\u0005\u02eb", + "\u27ca\n\u02eb\u0003\u02ec\u0003\u02ec\u0003\u02ec\u0005\u02ec\u27cf", + "\n\u02ec\u0003\u02ed\u0003\u02ed\u0003\u02ee\u0003\u02ee\u0003\u02ee", + "\u0003\u02ee\u0003\u02ee\u0003\u02ee\u0003\u02ee\u0003\u02ee\u0003\u02ee", + "\u0003\u02ef\u0003\u02ef\u0003\u02ef\u0005\u02ef\u27df\n\u02ef\u0003", + "\u02f0\u0003\u02f0\u0003\u02f0\u0003\u02f0\u0003\u02f0\u0003\u02f1\u0003", + "\u02f1\u0003\u02f2\u0003\u02f2\u0003\u02f2\u0003\u02f2\u0003\u02f2\u0003", + "\u02f2\u0003\u02f2\u0003\u02f2\u0003\u02f2\u0005\u02f2\u27f1\n\u02f2", + "\u0003\u02f2\u0005\u02f2\u27f4\n\u02f2\u0003\u02f2\u0003\u02f2\u0003", + "\u02f3\u0003\u02f3\u0005\u02f3\u27fa\n\u02f3\u0003\u02f4\u0003\u02f4", + "\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4", + "\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4", + "\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4", + "\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4\u0003\u02f4", + "\u0005\u02f4\u2816\n\u02f4\u0003\u02f5\u0003\u02f5\u0003\u02f5\u0003", + "\u02f5\u0003\u02f5\u0003\u02f5\u0003\u02f5\u0003\u02f5\u0005\u02f5\u2820", + "\n\u02f5\u0003\u02f6\u0003\u02f6\u0003\u02f6\u0006\u02f6\u2825\n\u02f6", + "\r\u02f6\u000e\u02f6\u2826\u0005\u02f6\u2829\n\u02f6\u0003\u02f7\u0003", + "\u02f7\u0003\u02f7\u0005\u02f7\u282e\n\u02f7\u0003\u02f8\u0003\u02f8", + "\u0003\u02f8\u0003\u02f8\u0003\u02f9\u0003\u02f9\u0003\u02f9\u0007\u02f9", + "\u2837\n\u02f9\f\u02f9\u000e\u02f9\u283a\u000b\u02f9\u0003\u02fa\u0003", + "\u02fa\u0003\u02fa\u0003\u02fa\u0003\u02fa\u0003\u02fb\u0003\u02fb\u0003", + "\u02fb\u0005\u02fb\u2844\n\u02fb\u0003\u02fc\u0003\u02fc\u0003\u02fc", + "\u0003\u02fc\u0003\u02fc\u0003\u02fc\u0003\u02fc\u0003\u02fd\u0003\u02fd", + "\u0003\u02fd\u0003\u02fe\u0003\u02fe\u0003\u02fe\u0003\u02fe\u0003\u02fe", + "\u0003\u02fe\u0003\u02fe\u0003\u02fe\u0003\u02fe\u0005\u02fe\u2859\n", + "\u02fe\u0003\u02fe\u0003\u02fe\u0003\u02ff\u0003\u02ff\u0003\u02ff\u0005", + "\u02ff\u2860\n\u02ff\u0003\u0300\u0003\u0300\u0003\u0300\u0007\u0300", + "\u2865\n\u0300\f\u0300\u000e\u0300\u2868\u000b\u0300\u0003\u0301\u0003", + "\u0301\u0003\u0301\u0005\u0301\u286d\n\u0301\u0003\u0301\u0005\u0301", + "\u2870\n\u0301\u0003\u0302\u0003\u0302\u0003\u0302\u0003\u0302\u0003", + "\u0302\u0003\u0302\u0003\u0302\u0003\u0302\u0003\u0302\u0005\u0302\u287b", + "\n\u0302\u0003\u0302\u0003\u0302\u0003\u0302\u0003\u0302\u0003\u0302", + "\u0005\u0302\u2882\n\u0302\u0005\u0302\u2884\n\u0302\u0003\u0302\u0003", + "\u0302\u0003\u0303\u0003\u0303\u0003\u0303\u0003\u0303\u0003\u0303\u0005", + "\u0303\u288d\n\u0303\u0003\u0304\u0003\u0304\u0003\u0304\u0007\u0304", + "\u2892\n\u0304\f\u0304\u000e\u0304\u2895\u000b\u0304\u0003\u0305\u0003", + "\u0305\u0003\u0305\u0005\u0305\u289a\n\u0305\u0003\u0306\u0003\u0306", + "\u0003\u0306\u0003\u0306\u0005\u0306\u28a0\n\u0306\u0003\u0307\u0003", + "\u0307\u0005\u0307\u28a4\n\u0307\u0003\u0308\u0003\u0308\u0003\u0308", + "\u0003\u0308\u0003\u0308\u0003\u0308\u0003\u0308\u0003\u0308\u0003\u0309", + "\u0003\u0309\u0003\u030a\u0003\u030a\u0003\u030a\u0005\u030a\u28b3\n", + "\u030a\u0003\u030b\u0003\u030b\u0003\u030b\u0003\u030b\u0003\u030b\u0003", + "\u030b\u0003\u030b\u0003\u030b\u0003\u030b\u0003\u030b\u0003\u030b\u0003", + "\u030b\u0003\u030b\u0003\u030b\u0003\u030b\u0005\u030b\u28c4\n\u030b", + "\u0005\u030b\u28c6\n\u030b\u0003\u030c\u0003\u030c\u0003\u030c\u0003", + "\u030c\u0003\u030c\u0003\u030d\u0003\u030d\u0003\u030d\u0003\u030d\u0003", + "\u030e\u0003\u030e\u0003\u030e\u0003\u030f\u0003\u030f\u0003\u030f\u0003", + "\u030f\u0003\u0310\u0003\u0310\u0003\u0310\u0003\u0310\u0003\u0311\u0003", + "\u0311\u0005\u0311\u28de\n\u0311\u0003\u0311\u0003\u0311\u0005\u0311", + "\u28e2\n\u0311\u0003\u0312\u0003\u0312\u0003\u0312\u0003\u0312\u0003", + "\u0312\u0003\u0312\u0003\u0312\u0003\u0312\u0003\u0312\u0005\u0312\u28ed", + "\n\u0312\u0003\u0312\u0005\u0312\u28f0\n\u0312\u0003\u0313\u0003\u0313", + "\u0005\u0313\u28f4\n\u0313\u0003\u0314\u0003\u0314\u0003\u0314\u0005", + "\u0314\u28f9\n\u0314\u0003\u0315\u0006\u0315\u28fc\n\u0315\r\u0315\u000e", + "\u0315\u28fd\u0003\u0316\u0003\u0316\u0003\u0316\u0003\u0316\u0003\u0316", + "\u0003\u0317\u0003\u0317\u0003\u0317\u0007\u0317\u2908\n\u0317\f\u0317", + "\u000e\u0317\u290b\u000b\u0317\u0003\u0318\u0003\u0318\u0003\u0318\u0005", + "\u0318\u2910\n\u0318\u0003\u0319\u0003\u0319\u0005\u0319\u2914\n\u0319", + "\u0003\u031a\u0003\u031a\u0005\u031a\u2918\n\u031a\u0003\u031b\u0003", + "\u031b\u0005\u031b\u291c\n\u031b\u0003\u031c\u0003\u031c\u0003\u031c", + "\u0005\u031c\u2921\n\u031c\u0003\u031d\u0003\u031d\u0005\u031d\u2925", + "\n\u031d\u0003\u031e\u0003\u031e\u0003\u031f\u0003\u031f\u0003\u031f", + "\u0003\u031f\u0003\u031f\u0003\u031f\u0003\u031f\u0003\u031f\u0003\u0320", + "\u0003\u0320\u0003\u0321\u0003\u0321\u0003\u0322\u0003\u0322\u0003\u0323", + "\u0003\u0323\u0003\u0324\u0003\u0324\u0003\u0324\u0003\u0325\u0003\u0325", + "\u0003\u0325\u0003\u0325\u0003\u0325\u0005\u0325\u2941\n\u0325\u0003", + "\u0325\u0002\u0003\u04aa\u0326\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012", + "\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ", + "\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e", + "\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6", + "\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be", + "\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6", + "\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee", + "\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106", + "\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e", + "\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136", + "\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e", + "\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166", + "\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c\u017e", + "\u0180\u0182\u0184\u0186\u0188\u018a\u018c\u018e\u0190\u0192\u0194\u0196", + "\u0198\u019a\u019c\u019e\u01a0\u01a2\u01a4\u01a6\u01a8\u01aa\u01ac\u01ae", + "\u01b0\u01b2\u01b4\u01b6\u01b8\u01ba\u01bc\u01be\u01c0\u01c2\u01c4\u01c6", + "\u01c8\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc\u01de", + "\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f0\u01f2\u01f4\u01f6", + "\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e", + "\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226", + "\u0228\u022a\u022c\u022e\u0230\u0232\u0234\u0236\u0238\u023a\u023c\u023e", + "\u0240\u0242\u0244\u0246\u0248\u024a\u024c\u024e\u0250\u0252\u0254\u0256", + "\u0258\u025a\u025c\u025e\u0260\u0262\u0264\u0266\u0268\u026a\u026c\u026e", + "\u0270\u0272\u0274\u0276\u0278\u027a\u027c\u027e\u0280\u0282\u0284\u0286", + "\u0288\u028a\u028c\u028e\u0290\u0292\u0294\u0296\u0298\u029a\u029c\u029e", + "\u02a0\u02a2\u02a4\u02a6\u02a8\u02aa\u02ac\u02ae\u02b0\u02b2\u02b4\u02b6", + "\u02b8\u02ba\u02bc\u02be\u02c0\u02c2\u02c4\u02c6\u02c8\u02ca\u02cc\u02ce", + "\u02d0\u02d2\u02d4\u02d6\u02d8\u02da\u02dc\u02de\u02e0\u02e2\u02e4\u02e6", + "\u02e8\u02ea\u02ec\u02ee\u02f0\u02f2\u02f4\u02f6\u02f8\u02fa\u02fc\u02fe", + "\u0300\u0302\u0304\u0306\u0308\u030a\u030c\u030e\u0310\u0312\u0314\u0316", + "\u0318\u031a\u031c\u031e\u0320\u0322\u0324\u0326\u0328\u032a\u032c\u032e", + "\u0330\u0332\u0334\u0336\u0338\u033a\u033c\u033e\u0340\u0342\u0344\u0346", + "\u0348\u034a\u034c\u034e\u0350\u0352\u0354\u0356\u0358\u035a\u035c\u035e", + "\u0360\u0362\u0364\u0366\u0368\u036a\u036c\u036e\u0370\u0372\u0374\u0376", + "\u0378\u037a\u037c\u037e\u0380\u0382\u0384\u0386\u0388\u038a\u038c\u038e", + "\u0390\u0392\u0394\u0396\u0398\u039a\u039c\u039e\u03a0\u03a2\u03a4\u03a6", + "\u03a8\u03aa\u03ac\u03ae\u03b0\u03b2\u03b4\u03b6\u03b8\u03ba\u03bc\u03be", + "\u03c0\u03c2\u03c4\u03c6\u03c8\u03ca\u03cc\u03ce\u03d0\u03d2\u03d4\u03d6", + "\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee", + "\u03f0\u03f2\u03f4\u03f6\u03f8\u03fa\u03fc\u03fe\u0400\u0402\u0404\u0406", + "\u0408\u040a\u040c\u040e\u0410\u0412\u0414\u0416\u0418\u041a\u041c\u041e", + "\u0420\u0422\u0424\u0426\u0428\u042a\u042c\u042e\u0430\u0432\u0434\u0436", + "\u0438\u043a\u043c\u043e\u0440\u0442\u0444\u0446\u0448\u044a\u044c\u044e", + "\u0450\u0452\u0454\u0456\u0458\u045a\u045c\u045e\u0460\u0462\u0464\u0466", + "\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e", + "\u0480\u0482\u0484\u0486\u0488\u048a\u048c\u048e\u0490\u0492\u0494\u0496", + "\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae", + "\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0\u04c2\u04c4\u04c6", + "\u04c8\u04ca\u04cc\u04ce\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de", + "\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6", + "\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e", + "\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526", + "\u0528\u052a\u052c\u052e\u0530\u0532\u0534\u0536\u0538\u053a\u053c\u053e", + "\u0540\u0542\u0544\u0546\u0548\u054a\u054c\u054e\u0550\u0552\u0554\u0556", + "\u0558\u055a\u055c\u055e\u0560\u0562\u0564\u0566\u0568\u056a\u056c\u056e", + "\u0570\u0572\u0574\u0576\u0578\u057a\u057c\u057e\u0580\u0582\u0584\u0586", + "\u0588\u058a\u058c\u058e\u0590\u0592\u0594\u0596\u0598\u059a\u059c\u059e", + "\u05a0\u05a2\u05a4\u05a6\u05a8\u05aa\u05ac\u05ae\u05b0\u05b2\u05b4\u05b6", + "\u05b8\u05ba\u05bc\u05be\u05c0\u05c2\u05c4\u05c6\u05c8\u05ca\u05cc\u05ce", + "\u05d0\u05d2\u05d4\u05d6\u05d8\u05da\u05dc\u05de\u05e0\u05e2\u05e4\u05e6", + "\u05e8\u05ea\u05ec\u05ee\u05f0\u05f2\u05f4\u05f6\u05f8\u05fa\u05fc\u05fe", + "\u0600\u0602\u0604\u0606\u0608\u060a\u060c\u060e\u0610\u0612\u0614\u0616", + "\u0618\u061a\u061c\u061e\u0620\u0622\u0624\u0626\u0628\u062a\u062c\u062e", + "\u0630\u0632\u0634\u0636\u0638\u063a\u063c\u063e\u0640\u0642\u0644\u0646", + "\u0648\u0002C\u0004\u0002\u00c5\u00c5\u0165\u0165\u0004\u0002DD\u0137", + "\u0137\u0004\u0002ee\u0137\u0137\u0005\u0002DDee\u0137\u0137\u0004\u0002", + "\u0087\u0087\u00c1\u00c1\u0004\u0002\u00f7\u00f7\u0145\u0145\u0004\u0002", + "\f\f``\u0004\u0002\u00a4\u00a4\u0164\u0164\u0004\u0002\u00b6\u00b6\u00df", + "\u00df\u0007\u0002 \u0119\u0119\u0142\u0142\u0159\u0159\u015b\u015b", + "\u0004\u0002BB``\u0004\u0002\u0159\u0159\u015b\u015b\u0004\u0002\u00ca", + "\u00ca\u00e2\u00e2\u000b\u0002 \u00a2\u00a2\u00a7\u00a7\u00b5\u00b5", + "\u00dd\u00dd\u00e5\u00e5\u014f\u014f\u0152\u0152\u01af\u01af\u0005\u0002", + "ss\u0115\u0115\u0149\u0149\u0004\u000277PP\u0005\u0002\u00af\u00af\u00fd", + "\u00fd\u00ff\u00ff\u0007\u0002 ZZ\u00b8\u00b8\u00ea\u00ea\u016a\u016a", + "\u0004\u0002^^\u00e4\u00e4\u0003\u0002\u01b9\u01ba\u0004\u0002^^\u0197", + "\u0197\u0004\u0002\u014e\u014e\u0197\u0197\u0004\u0002\u00d5\u00d5\u0121", + "\u0121\u0005\u0002\u013a\u013a\u015e\u015e\u01b6\u01b6\u0004\u0002B", + "BFF\u0007\u0002\u00d6\u00d6\u0142\u0142\u0157\u0157\u0162\u0162\u01c0", + "\u01c1\u0004\u0002\f\f77\u0005\u0002\u00d5\u00d5\u0121\u0121\u01b3\u01b3", + "\u0005\u0002\u00b1\u00b1\u013c\u013c\u0156\u0156\u0006\u0002ZZ\u00b8", + "\u00b8\u00ea\u00ea\u016a\u016a\u0004\u0002\u0099\u0099\u00f7\u00f7\u0004", + "\u0002\u0132\u0132\u0146\u0146\u0003\u0002!\"\u0004\u0002ee\u0156\u0156", + "\u0004\u0002\u00cb\u00cb\u0147\u0147\u0004\u0002\u00d7\u00d7\u00f7\u00f7", + "\u0004\u0002\u0139\u0139\u0197\u0197\u0004\u0002\u00d1\u00d1\u0105\u0105", + "\u0006\u0002ssuuyy\u0080\u0080\u0004\u0002\u0161\u0161\u01d6\u01d6\u0004", + "\u0002\u0180\u0181\u018f\u018f\u0003\u0002\u0180\u0181\u0003\u0002\u019b", + "\u019c\u0003\u0002\u0014\u0015\u0004\u0002ww||\u0007\u0002\f\f\u0012", + "\u0013\u0017\u0017\u0019\u0019\u001b\u001b\u0003\u0002\u000e\u000f\u0005", + "\u0002\u000b\u000b\u0010\u0010\u001d\u001d\u0004\u0002 ::\u0005\u0002", + "))KKaa\u0004\u0002\u00a8\u00a8\u00be\u00be\u0004\u0002\u0129\u0129\u01bb", + "\u01bb\u0004\u0002\u00d2\u00d2\u011a\u011a\u0005\u0002 $$\\\\\b\u0002", + "\u000b\f\u000e\u0013\u0017\u0017\u0019\u0019\u001b\u001b\u001d\u001d", + "\u0004\u0002\u0016\u0016\u0018\u0018\u0003\u0002\u01dc\u01df\n\u0002", + "~~\u0083\u017b\u01aa\u01bd\u01c0\u01ce\u01d0\u01d0\u01d2\u01d2\u01d4", + "\u01d4\u01d7\u01e1\u0005\u0002l}\u007f\u0082\u01d1\u01d1\u0006\u0002", + " 68HJk\u01bf\u01bf\u0004\u0002@@vv\u0004\u0002\f\f\u0016\u0016\u0004", + "\u0002\u00a9\u00a9\u01f4\u01f4\u0004\u0002\u0092\u0092\u00d4\u00d4&", + "\u0002##%%-/77;;??^^vv}}\u0084\u0084\u0092\u0092\u009b\u009b\u009f\u009f", + "\u00a3\u00a3\u00a9\u00a9\u00ae\u00ae\u00d1\u00d1\u00d4\u00d4\u00ea\u00ea", + "\u00f2\u00f2\u0102\u0102\u0105\u0106\u0110\u0110\u011e\u011e\u012c\u012c", + "\u0132\u0132\u0138\u0138\u013c\u013d\u0146\u0146\u0161\u0161\u01aa\u01ab", + "\u01d6\u01d6\u01e3\u01ef\u01f1\u01f1\u01f3\u01ff\u0201\u0201\u0002\u2c87", + "\u0002\u064a\u0003\u0002\u0002\u0002\u0004\u064d\u0003\u0002\u0002\u0002", + "\u0006\u064f\u0003\u0002\u0002\u0002\b\u0657\u0003\u0002\u0002\u0002", + "\n\u06d6\u0003\u0002\u0002\u0002\f\u06d8\u0003\u0002\u0002\u0002\u000e", + "\u06dc\u0003\u0002\u0002\u0002\u0010\u06df\u0003\u0002\u0002\u0002\u0012", + "\u06e7\u0003\u0002\u0002\u0002\u0014\u06ec\u0003\u0002\u0002\u0002\u0016", + "\u06f2\u0003\u0002\u0002\u0002\u0018\u0707\u0003\u0002\u0002\u0002\u001a", + "\u0713\u0003\u0002\u0002\u0002\u001c\u0715\u0003\u0002\u0002\u0002\u001e", + "\u071b\u0003\u0002\u0002\u0002 \u0725\u0003\u0002\u0002\u0002\"\u0727", + "\u0003\u0002\u0002\u0002$\u0730\u0003\u0002\u0002\u0002&\u0738\u0003", + "\u0002\u0002\u0002(\u073e\u0003\u0002\u0002\u0002*\u0745\u0003\u0002", + "\u0002\u0002,\u0747\u0003\u0002\u0002\u0002.\u0759\u0003\u0002\u0002", + "\u00020\u075e\u0003\u0002\u0002\u00022\u0767\u0003\u0002\u0002\u0002", + "4\u0769\u0003\u0002\u0002\u00026\u0777\u0003\u0002\u0002\u00028\u0779", + "\u0003\u0002\u0002\u0002:\u0796\u0003\u0002\u0002\u0002<\u0798\u0003", + "\u0002\u0002\u0002>\u07a0\u0003\u0002\u0002\u0002@\u07aa\u0003\u0002", + "\u0002\u0002B\u07b1\u0003\u0002\u0002\u0002D\u07b7\u0003\u0002\u0002", + "\u0002F\u07c8\u0003\u0002\u0002\u0002H\u07cd\u0003\u0002\u0002\u0002", + "J\u07d1\u0003\u0002\u0002\u0002L\u07d3\u0003\u0002\u0002\u0002N\u07de", + "\u0003\u0002\u0002\u0002P\u07e2\u0003\u0002\u0002\u0002R\u07e7\u0003", + "\u0002\u0002\u0002T\u07ec\u0003\u0002\u0002\u0002V\u07ee\u0003\u0002", + "\u0002\u0002X\u07fa\u0003\u0002\u0002\u0002Z\u0801\u0003\u0002\u0002", + "\u0002\\\u0803\u0003\u0002\u0002\u0002^\u0805\u0003\u0002\u0002\u0002", + "`\u0807\u0003\u0002\u0002\u0002b\u0877\u0003\u0002\u0002\u0002d\u0879", + "\u0003\u0002\u0002\u0002f\u0889\u0003\u0002\u0002\u0002h\u088b\u0003", + "\u0002\u0002\u0002j\u098b\u0003\u0002\u0002\u0002l\u0992\u0003\u0002", + "\u0002\u0002n\u0997\u0003\u0002\u0002\u0002p\u099c\u0003\u0002\u0002", + "\u0002r\u09a1\u0003\u0002\u0002\u0002t\u09a9\u0003\u0002\u0002\u0002", + "v\u09ab\u0003\u0002\u0002\u0002x\u09b2\u0003\u0002\u0002\u0002z\u09b4", + "\u0003\u0002\u0002\u0002|\u09bc\u0003\u0002\u0002\u0002~\u09c8\u0003", + "\u0002\u0002\u0002\u0080\u09d8\u0003\u0002\u0002\u0002\u0082\u09f4\u0003", + "\u0002\u0002\u0002\u0084\u09f6\u0003\u0002\u0002\u0002\u0086\u09f9\u0003", + "\u0002\u0002\u0002\u0088\u0a01\u0003\u0002\u0002\u0002\u008a\u0a06\u0003", + "\u0002\u0002\u0002\u008c\u0a25\u0003\u0002\u0002\u0002\u008e\u0a27\u0003", + "\u0002\u0002\u0002\u0090\u0a42\u0003\u0002\u0002\u0002\u0092\u0a44\u0003", + "\u0002\u0002\u0002\u0094\u0a48\u0003\u0002\u0002\u0002\u0096\u0a4d\u0003", + "\u0002\u0002\u0002\u0098\u0a54\u0003\u0002\u0002\u0002\u009a\u0a59\u0003", + "\u0002\u0002\u0002\u009c\u0a7f\u0003\u0002\u0002\u0002\u009e\u0a83\u0003", + "\u0002\u0002\u0002\u00a0\u0a8a\u0003\u0002\u0002\u0002\u00a2\u0a8e\u0003", + "\u0002\u0002\u0002\u00a4\u0a90\u0003\u0002\u0002\u0002\u00a6\u0a98\u0003", + "\u0002\u0002\u0002\u00a8\u0aa3\u0003\u0002\u0002\u0002\u00aa\u0aa5\u0003", + "\u0002\u0002\u0002\u00ac\u0aad\u0003\u0002\u0002\u0002\u00ae\u0aaf\u0003", + "\u0002\u0002\u0002\u00b0\u0ae0\u0003\u0002\u0002\u0002\u00b2\u0ae4\u0003", + "\u0002\u0002\u0002\u00b4\u0aeb\u0003\u0002\u0002\u0002\u00b6\u0aed\u0003", + "\u0002\u0002\u0002\u00b8\u0af5\u0003\u0002\u0002\u0002\u00ba\u0b00\u0003", + "\u0002\u0002\u0002\u00bc\u0b04\u0003\u0002\u0002\u0002\u00be\u0b06\u0003", + "\u0002\u0002\u0002\u00c0\u0b0b\u0003\u0002\u0002\u0002\u00c2\u0b15\u0003", + "\u0002\u0002\u0002\u00c4\u0b20\u0003\u0002\u0002\u0002\u00c6\u0b48\u0003", + "\u0002\u0002\u0002\u00c8\u0b4d\u0003\u0002\u0002\u0002\u00ca\u0b54\u0003", + "\u0002\u0002\u0002\u00cc\u0b56\u0003\u0002\u0002\u0002\u00ce\u0b5e\u0003", + "\u0002\u0002\u0002\u00d0\u0b61\u0003\u0002\u0002\u0002\u00d2\u0b68\u0003", + "\u0002\u0002\u0002\u00d4\u0ba4\u0003\u0002\u0002\u0002\u00d6\u0ba9\u0003", + "\u0002\u0002\u0002\u00d8\u0bb0\u0003\u0002\u0002\u0002\u00da\u0bb2\u0003", + "\u0002\u0002\u0002\u00dc\u0bba\u0003\u0002\u0002\u0002\u00de\u0bc2\u0003", + "\u0002\u0002\u0002\u00e0\u0bc7\u0003\u0002\u0002\u0002\u00e2\u0bc9\u0003", + "\u0002\u0002\u0002\u00e4\u0bd1\u0003\u0002\u0002\u0002\u00e6\u0be1\u0003", + "\u0002\u0002\u0002\u00e8\u0bec\u0003\u0002\u0002\u0002\u00ea\u0bee\u0003", + "\u0002\u0002\u0002\u00ec\u0bf2\u0003\u0002\u0002\u0002\u00ee\u0bfc\u0003", + "\u0002\u0002\u0002\u00f0\u0c04\u0003\u0002\u0002\u0002\u00f2\u0c08\u0003", + "\u0002\u0002\u0002\u00f4\u0c0a\u0003\u0002\u0002\u0002\u00f6\u0c11\u0003", + "\u0002\u0002\u0002\u00f8\u0c27\u0003\u0002\u0002\u0002\u00fa\u0c2c\u0003", + "\u0002\u0002\u0002\u00fc\u0c33\u0003\u0002\u0002\u0002\u00fe\u0c3f\u0003", + "\u0002\u0002\u0002\u0100\u0c44\u0003\u0002\u0002\u0002\u0102\u0c4b\u0003", + "\u0002\u0002\u0002\u0104\u0c4d\u0003\u0002\u0002\u0002\u0106\u0c51\u0003", + "\u0002\u0002\u0002\u0108\u0c5f\u0003\u0002\u0002\u0002\u010a\u0c6a\u0003", + "\u0002\u0002\u0002\u010c\u0c77\u0003\u0002\u0002\u0002\u010e\u0c85\u0003", + "\u0002\u0002\u0002\u0110\u0c87\u0003\u0002\u0002\u0002\u0112\u0c95\u0003", + "\u0002\u0002\u0002\u0114\u0c9d\u0003\u0002\u0002\u0002\u0116\u0c9f\u0003", + "\u0002\u0002\u0002\u0118\u0ca6\u0003\u0002\u0002\u0002\u011a\u0cb1\u0003", + "\u0002\u0002\u0002\u011c\u0cbc\u0003\u0002\u0002\u0002\u011e\u0cc3\u0003", + "\u0002\u0002\u0002\u0120\u0cc6\u0003\u0002\u0002\u0002\u0122\u0ce8\u0003", + "\u0002\u0002\u0002\u0124\u0cec\u0003\u0002\u0002\u0002\u0126\u0cf4\u0003", + "\u0002\u0002\u0002\u0128\u0cf6\u0003\u0002\u0002\u0002\u012a\u0cfe\u0003", + "\u0002\u0002\u0002\u012c\u0d0d\u0003\u0002\u0002\u0002\u012e\u0d0f\u0003", + "\u0002\u0002\u0002\u0130\u0d16\u0003\u0002\u0002\u0002\u0132\u0d1c\u0003", + "\u0002\u0002\u0002\u0134\u0d20\u0003\u0002\u0002\u0002\u0136\u0d24\u0003", + "\u0002\u0002\u0002\u0138\u0d26\u0003\u0002\u0002\u0002\u013a\u0d31\u0003", + "\u0002\u0002\u0002\u013c\u0d33\u0003\u0002\u0002\u0002\u013e\u0d3b\u0003", + "\u0002\u0002\u0002\u0140\u0d49\u0003\u0002\u0002\u0002\u0142\u0d53\u0003", + "\u0002\u0002\u0002\u0144\u0d55\u0003\u0002\u0002\u0002\u0146\u0d5e\u0003", + "\u0002\u0002\u0002\u0148\u0d61\u0003\u0002\u0002\u0002\u014a\u0dcc\u0003", + "\u0002\u0002\u0002\u014c\u0dce\u0003\u0002\u0002\u0002\u014e\u0dde\u0003", + "\u0002\u0002\u0002\u0150\u0de1\u0003\u0002\u0002\u0002\u0152\u0de7\u0003", + "\u0002\u0002\u0002\u0154\u0df8\u0003\u0002\u0002\u0002\u0156\u0e00\u0003", + "\u0002\u0002\u0002\u0158\u0e02\u0003\u0002\u0002\u0002\u015a\u0e0a\u0003", + "\u0002\u0002\u0002\u015c\u0e0f\u0003\u0002\u0002\u0002\u015e\u0e1e\u0003", + "\u0002\u0002\u0002\u0160\u0e20\u0003\u0002\u0002\u0002\u0162\u0e23\u0003", + "\u0002\u0002\u0002\u0164\u0e25\u0003\u0002\u0002\u0002\u0166\u0e40\u0003", + "\u0002\u0002\u0002\u0168\u0e45\u0003\u0002\u0002\u0002\u016a\u0e47\u0003", + "\u0002\u0002\u0002\u016c\u0e4e\u0003\u0002\u0002\u0002\u016e\u0e50\u0003", + "\u0002\u0002\u0002\u0170\u0e92\u0003\u0002\u0002\u0002\u0172\u0e94\u0003", + "\u0002\u0002\u0002\u0174\u0ea3\u0003\u0002\u0002\u0002\u0176\u0eab\u0003", + "\u0002\u0002\u0002\u0178\u0ec2\u0003\u0002\u0002\u0002\u017a\u0ec6\u0003", + "\u0002\u0002\u0002\u017c\u0eda\u0003\u0002\u0002\u0002\u017e\u0edc\u0003", + "\u0002\u0002\u0002\u0180\u0ee5\u0003\u0002\u0002\u0002\u0182\u0ef0\u0003", + "\u0002\u0002\u0002\u0184\u0eff\u0003\u0002\u0002\u0002\u0186\u0f08\u0003", + "\u0002\u0002\u0002\u0188\u0f0d\u0003\u0002\u0002\u0002\u018a\u0f12\u0003", + "\u0002\u0002\u0002\u018c\u0f17\u0003\u0002\u0002\u0002\u018e\u0f1c\u0003", + "\u0002\u0002\u0002\u0190\u0f1e\u0003\u0002\u0002\u0002\u0192\u0f20\u0003", + "\u0002\u0002\u0002\u0194\u0f29\u0003\u0002\u0002\u0002\u0196\u0f51\u0003", + "\u0002\u0002\u0002\u0198\u0f57\u0003\u0002\u0002\u0002\u019a\u0f59\u0003", + "\u0002\u0002\u0002\u019c\u0f68\u0003\u0002\u0002\u0002\u019e\u0f6d\u0003", + "\u0002\u0002\u0002\u01a0\u0f70\u0003\u0002\u0002\u0002\u01a2\u0f74\u0003", + "\u0002\u0002\u0002\u01a4\u0f79\u0003\u0002\u0002\u0002\u01a6\u0f7b\u0003", + "\u0002\u0002\u0002\u01a8\u0f7d\u0003\u0002\u0002\u0002\u01aa\u0f84\u0003", + "\u0002\u0002\u0002\u01ac\u0f88\u0003\u0002\u0002\u0002\u01ae\u0f8a\u0003", + "\u0002\u0002\u0002\u01b0\u0f92\u0003\u0002\u0002\u0002\u01b2\u0f94\u0003", + "\u0002\u0002\u0002\u01b4\u0f98\u0003\u0002\u0002\u0002\u01b6\u0fa5\u0003", + "\u0002\u0002\u0002\u01b8\u0faa\u0003\u0002\u0002\u0002\u01ba\u0faf\u0003", + "\u0002\u0002\u0002\u01bc\u0fbd\u0003\u0002\u0002\u0002\u01be\u0fd9\u0003", + "\u0002\u0002\u0002\u01c0\u0fdb\u0003\u0002\u0002\u0002\u01c2\u0fe3\u0003", + "\u0002\u0002\u0002\u01c4\u0fe9\u0003\u0002\u0002\u0002\u01c6\u0ff1\u0003", + "\u0002\u0002\u0002\u01c8\u0ffd\u0003\u0002\u0002\u0002\u01ca\u0fff\u0003", + "\u0002\u0002\u0002\u01cc\u1072\u0003\u0002\u0002\u0002\u01ce\u1074\u0003", + "\u0002\u0002\u0002\u01d0\u1078\u0003\u0002\u0002\u0002\u01d2\u1080\u0003", + "\u0002\u0002\u0002\u01d4\u108b\u0003\u0002\u0002\u0002\u01d6\u108d\u0003", + "\u0002\u0002\u0002\u01d8\u1091\u0003\u0002\u0002\u0002\u01da\u1099\u0003", + "\u0002\u0002\u0002\u01dc\u109f\u0003\u0002\u0002\u0002\u01de\u10a1\u0003", + "\u0002\u0002\u0002\u01e0\u10ce\u0003\u0002\u0002\u0002\u01e2\u10d4\u0003", + "\u0002\u0002\u0002\u01e4\u10d6\u0003\u0002\u0002\u0002\u01e6\u10e4\u0003", + "\u0002\u0002\u0002\u01e8\u1105\u0003\u0002\u0002\u0002\u01ea\u1109\u0003", + "\u0002\u0002\u0002\u01ec\u110e\u0003\u0002\u0002\u0002\u01ee\u1117\u0003", + "\u0002\u0002\u0002\u01f0\u111b\u0003\u0002\u0002\u0002\u01f2\u111d\u0003", + "\u0002\u0002\u0002\u01f4\u1136\u0003\u0002\u0002\u0002\u01f6\u1138\u0003", + "\u0002\u0002\u0002\u01f8\u114c\u0003\u0002\u0002\u0002\u01fa\u1160\u0003", + "\u0002\u0002\u0002\u01fc\u1174\u0003\u0002\u0002\u0002\u01fe\u1176\u0003", + "\u0002\u0002\u0002\u0200\u117c\u0003\u0002\u0002\u0002\u0202\u11d1\u0003", + "\u0002\u0002\u0002\u0204\u11ea\u0003\u0002\u0002\u0002\u0206\u11f1\u0003", + "\u0002\u0002\u0002\u0208\u1201\u0003\u0002\u0002\u0002\u020a\u1203\u0003", + "\u0002\u0002\u0002\u020c\u1205\u0003\u0002\u0002\u0002\u020e\u120d\u0003", + "\u0002\u0002\u0002\u0210\u1213\u0003\u0002\u0002\u0002\u0212\u1217\u0003", + "\u0002\u0002\u0002\u0214\u121f\u0003\u0002\u0002\u0002\u0216\u122a\u0003", + "\u0002\u0002\u0002\u0218\u12bf\u0003\u0002\u0002\u0002\u021a\u12c3\u0003", + "\u0002\u0002\u0002\u021c\u1320\u0003\u0002\u0002\u0002\u021e\u1325\u0003", + "\u0002\u0002\u0002\u0220\u1329\u0003\u0002\u0002\u0002\u0222\u132f\u0003", + "\u0002\u0002\u0002\u0224\u1373\u0003\u0002\u0002\u0002\u0226\u1375\u0003", + "\u0002\u0002\u0002\u0228\u1379\u0003\u0002\u0002\u0002\u022a\u137b\u0003", + "\u0002\u0002\u0002\u022c\u1396\u0003\u0002\u0002\u0002\u022e\u13a7\u0003", + "\u0002\u0002\u0002\u0230\u13a9\u0003\u0002\u0002\u0002\u0232\u13ba\u0003", + "\u0002\u0002\u0002\u0234\u13f6\u0003\u0002\u0002\u0002\u0236\u13f8\u0003", + "\u0002\u0002\u0002\u0238\u1403\u0003\u0002\u0002\u0002\u023a\u1409\u0003", + "\u0002\u0002\u0002\u023c\u140b\u0003\u0002\u0002\u0002\u023e\u1423\u0003", + "\u0002\u0002\u0002\u0240\u1429\u0003\u0002\u0002\u0002\u0242\u142f\u0003", + "\u0002\u0002\u0002\u0244\u1431\u0003\u0002\u0002\u0002\u0246\u143a\u0003", + "\u0002\u0002\u0002\u0248\u1446\u0003\u0002\u0002\u0002\u024a\u1463\u0003", + "\u0002\u0002\u0002\u024c\u1465\u0003\u0002\u0002\u0002\u024e\u148a\u0003", + "\u0002\u0002\u0002\u0250\u148e\u0003\u0002\u0002\u0002\u0252\u1492\u0003", + "\u0002\u0002\u0002\u0254\u1496\u0003\u0002\u0002\u0002\u0256\u149b\u0003", + "\u0002\u0002\u0002\u0258\u149d\u0003\u0002\u0002\u0002\u025a\u14b0\u0003", + "\u0002\u0002\u0002\u025c\u14bd\u0003\u0002\u0002\u0002\u025e\u14c5\u0003", + "\u0002\u0002\u0002\u0260\u14c7\u0003\u0002\u0002\u0002\u0262\u14d2\u0003", + "\u0002\u0002\u0002\u0264\u14d6\u0003\u0002\u0002\u0002\u0266\u14db\u0003", + "\u0002\u0002\u0002\u0268\u14e2\u0003\u0002\u0002\u0002\u026a\u14e4\u0003", + "\u0002\u0002\u0002\u026c\u14f9\u0003\u0002\u0002\u0002\u026e\u14fb\u0003", + "\u0002\u0002\u0002\u0270\u1501\u0003\u0002\u0002\u0002\u0272\u1509\u0003", + "\u0002\u0002\u0002\u0274\u1519\u0003\u0002\u0002\u0002\u0276\u151b\u0003", + "\u0002\u0002\u0002\u0278\u1521\u0003\u0002\u0002\u0002\u027a\u1536\u0003", + "\u0002\u0002\u0002\u027c\u153f\u0003\u0002\u0002\u0002\u027e\u1541\u0003", + "\u0002\u0002\u0002\u0280\u1543\u0003\u0002\u0002\u0002\u0282\u1551\u0003", + "\u0002\u0002\u0002\u0284\u1553\u0003\u0002\u0002\u0002\u0286\u1558\u0003", + "\u0002\u0002\u0002\u0288\u155a\u0003\u0002\u0002\u0002\u028a\u1569\u0003", + "\u0002\u0002\u0002\u028c\u1571\u0003\u0002\u0002\u0002\u028e\u1574\u0003", + "\u0002\u0002\u0002\u0290\u157d\u0003\u0002\u0002\u0002\u0292\u15a6\u0003", + "\u0002\u0002\u0002\u0294\u15b0\u0003\u0002\u0002\u0002\u0296\u15b7\u0003", + "\u0002\u0002\u0002\u0298\u15b9\u0003\u0002\u0002\u0002\u029a\u15c8\u0003", + "\u0002\u0002\u0002\u029c\u15ca\u0003\u0002\u0002\u0002\u029e\u15cd\u0003", + "\u0002\u0002\u0002\u02a0\u15d5\u0003\u0002\u0002\u0002\u02a2\u15dc\u0003", + "\u0002\u0002\u0002\u02a4\u15e2\u0003\u0002\u0002\u0002\u02a6\u1608\u0003", + "\u0002\u0002\u0002\u02a8\u1616\u0003\u0002\u0002\u0002\u02aa\u1624\u0003", + "\u0002\u0002\u0002\u02ac\u163c\u0003\u0002\u0002\u0002\u02ae\u1643\u0003", + "\u0002\u0002\u0002\u02b0\u1648\u0003\u0002\u0002\u0002\u02b2\u1650\u0003", + "\u0002\u0002\u0002\u02b4\u1653\u0003\u0002\u0002\u0002\u02b6\u1657\u0003", + "\u0002\u0002\u0002\u02b8\u165e\u0003\u0002\u0002\u0002\u02ba\u1682\u0003", + "\u0002\u0002\u0002\u02bc\u1689\u0003\u0002\u0002\u0002\u02be\u168b\u0003", + "\u0002\u0002\u0002\u02c0\u1698\u0003\u0002\u0002\u0002\u02c2\u169a\u0003", + "\u0002\u0002\u0002\u02c4\u16c7\u0003\u0002\u0002\u0002\u02c6\u16c9\u0003", + "\u0002\u0002\u0002\u02c8\u16ec\u0003\u0002\u0002\u0002\u02ca\u16ee\u0003", + "\u0002\u0002\u0002\u02cc\u16f0\u0003\u0002\u0002\u0002\u02ce\u16f2\u0003", + "\u0002\u0002\u0002\u02d0\u16fa\u0003\u0002\u0002\u0002\u02d2\u1708\u0003", + "\u0002\u0002\u0002\u02d4\u18de\u0003\u0002\u0002\u0002\u02d6\u18e2\u0003", + "\u0002\u0002\u0002\u02d8\u18e7\u0003\u0002\u0002\u0002\u02da\u1922\u0003", + "\u0002\u0002\u0002\u02dc\u1926\u0003\u0002\u0002\u0002\u02de\u1a01\u0003", + "\u0002\u0002\u0002\u02e0\u1a03\u0003\u0002\u0002\u0002\u02e2\u1a0b\u0003", + "\u0002\u0002\u0002\u02e4\u1a1b\u0003\u0002\u0002\u0002\u02e6\u1a22\u0003", + "\u0002\u0002\u0002\u02e8\u1a24\u0003\u0002\u0002\u0002\u02ea\u1ae3\u0003", + "\u0002\u0002\u0002\u02ec\u1ae5\u0003\u0002\u0002\u0002\u02ee\u1aed\u0003", + "\u0002\u0002\u0002\u02f0\u1af5\u0003\u0002\u0002\u0002\u02f2\u1b12\u0003", + "\u0002\u0002\u0002\u02f4\u1b14\u0003\u0002\u0002\u0002\u02f6\u1b1d\u0003", + "\u0002\u0002\u0002\u02f8\u1b25\u0003\u0002\u0002\u0002\u02fa\u1b4c\u0003", + "\u0002\u0002\u0002\u02fc\u1b5a\u0003\u0002\u0002\u0002\u02fe\u1b5c\u0003", + "\u0002\u0002\u0002\u0300\u1b70\u0003\u0002\u0002\u0002\u0302\u1b72\u0003", + "\u0002\u0002\u0002\u0304\u1b7f\u0003\u0002\u0002\u0002\u0306\u1b83\u0003", + "\u0002\u0002\u0002\u0308\u1b85\u0003\u0002\u0002\u0002\u030a\u1b8a\u0003", + "\u0002\u0002\u0002\u030c\u1b8c\u0003\u0002\u0002\u0002\u030e\u1b93\u0003", + "\u0002\u0002\u0002\u0310\u1b95\u0003\u0002\u0002\u0002\u0312\u1b9c\u0003", + "\u0002\u0002\u0002\u0314\u1bd0\u0003\u0002\u0002\u0002\u0316\u1bd5\u0003", + "\u0002\u0002\u0002\u0318\u1be1\u0003\u0002\u0002\u0002\u031a\u1be3\u0003", + "\u0002\u0002\u0002\u031c\u1bef\u0003\u0002\u0002\u0002\u031e\u1bf7\u0003", + "\u0002\u0002\u0002\u0320\u1bf9\u0003\u0002\u0002\u0002\u0322\u1c19\u0003", + "\u0002\u0002\u0002\u0324\u1c1b\u0003\u0002\u0002\u0002\u0326\u1c1e\u0003", + "\u0002\u0002\u0002\u0328\u1c26\u0003\u0002\u0002\u0002\u032a\u1c29\u0003", + "\u0002\u0002\u0002\u032c\u1c2d\u0003\u0002\u0002\u0002\u032e\u1c3c\u0003", + "\u0002\u0002\u0002\u0330\u1c40\u0003\u0002\u0002\u0002\u0332\u1c42\u0003", + "\u0002\u0002\u0002\u0334\u1c4d\u0003\u0002\u0002\u0002\u0336\u1c52\u0003", + "\u0002\u0002\u0002\u0338\u1c60\u0003\u0002\u0002\u0002\u033a\u1c68\u0003", + "\u0002\u0002\u0002\u033c\u1c6a\u0003\u0002\u0002\u0002\u033e\u1c70\u0003", + "\u0002\u0002\u0002\u0340\u1c75\u0003\u0002\u0002\u0002\u0342\u1c7c\u0003", + "\u0002\u0002\u0002\u0344\u1c98\u0003\u0002\u0002\u0002\u0346\u1c9a\u0003", + "\u0002\u0002\u0002\u0348\u1ce9\u0003\u0002\u0002\u0002\u034a\u1ceb\u0003", + "\u0002\u0002\u0002\u034c\u1ced\u0003\u0002\u0002\u0002\u034e\u1d05\u0003", + "\u0002\u0002\u0002\u0350\u1d0a\u0003\u0002\u0002\u0002\u0352\u1d19\u0003", + "\u0002\u0002\u0002\u0354\u1d25\u0003\u0002\u0002\u0002\u0356\u1d27\u0003", + "\u0002\u0002\u0002\u0358\u1d2f\u0003\u0002\u0002\u0002\u035a\u1d31\u0003", + "\u0002\u0002\u0002\u035c\u1d36\u0003\u0002\u0002\u0002\u035e\u1d3b\u0003", + "\u0002\u0002\u0002\u0360\u1d3f\u0003\u0002\u0002\u0002\u0362\u1d43\u0003", + "\u0002\u0002\u0002\u0364\u1d47\u0003\u0002\u0002\u0002\u0366\u1d4b\u0003", + "\u0002\u0002\u0002\u0368\u1d52\u0003\u0002\u0002\u0002\u036a\u1d54\u0003", + "\u0002\u0002\u0002\u036c\u1d57\u0003\u0002\u0002\u0002\u036e\u1d61\u0003", + "\u0002\u0002\u0002\u0370\u1d73\u0003\u0002\u0002\u0002\u0372\u1d7e\u0003", + "\u0002\u0002\u0002\u0374\u1d80\u0003\u0002\u0002\u0002\u0376\u1d88\u0003", + "\u0002\u0002\u0002\u0378\u1d8d\u0003\u0002\u0002\u0002\u037a\u1d92\u0003", + "\u0002\u0002\u0002\u037c\u1d94\u0003\u0002\u0002\u0002\u037e\u1d9f\u0003", + "\u0002\u0002\u0002\u0380\u1da5\u0003\u0002\u0002\u0002\u0382\u1dc2\u0003", + "\u0002\u0002\u0002\u0384\u1dc9\u0003\u0002\u0002\u0002\u0386\u1dd5\u0003", + "\u0002\u0002\u0002\u0388\u1dd7\u0003\u0002\u0002\u0002\u038a\u1ddf\u0003", + "\u0002\u0002\u0002\u038c\u1df7\u0003\u0002\u0002\u0002\u038e\u1df9\u0003", + "\u0002\u0002\u0002\u0390\u1dfb\u0003\u0002\u0002\u0002\u0392\u1e03\u0003", + "\u0002\u0002\u0002\u0394\u1e13\u0003\u0002\u0002\u0002\u0396\u1e1e\u0003", + "\u0002\u0002\u0002\u0398\u1e23\u0003\u0002\u0002\u0002\u039a\u1e25\u0003", + "\u0002\u0002\u0002\u039c\u1e30\u0003\u0002\u0002\u0002\u039e\u1e32\u0003", + "\u0002\u0002\u0002\u03a0\u1e3d\u0003\u0002\u0002\u0002\u03a2\u1e4b\u0003", + "\u0002\u0002\u0002\u03a4\u1e4f\u0003\u0002\u0002\u0002\u03a6\u1e55\u0003", + "\u0002\u0002\u0002\u03a8\u1e57\u0003\u0002\u0002\u0002\u03aa\u1e60\u0003", + "\u0002\u0002\u0002\u03ac\u1e72\u0003\u0002\u0002\u0002\u03ae\u1e74\u0003", + "\u0002\u0002\u0002\u03b0\u1e77\u0003\u0002\u0002\u0002\u03b2\u1e7f\u0003", + "\u0002\u0002\u0002\u03b4\u1e87\u0003\u0002\u0002\u0002\u03b6\u1e90\u0003", + "\u0002\u0002\u0002\u03b8\u1e98\u0003\u0002\u0002\u0002\u03ba\u1e9c\u0003", + "\u0002\u0002\u0002\u03bc\u1ea6\u0003\u0002\u0002\u0002\u03be\u1ebd\u0003", + "\u0002\u0002\u0002\u03c0\u1ec1\u0003\u0002\u0002\u0002\u03c2\u1edd\u0003", + "\u0002\u0002\u0002\u03c4\u1eec\u0003\u0002\u0002\u0002\u03c6\u1eee\u0003", + "\u0002\u0002\u0002\u03c8\u1ef1\u0003\u0002\u0002\u0002\u03ca\u1ef7\u0003", + "\u0002\u0002\u0002\u03cc\u1eff\u0003\u0002\u0002\u0002\u03ce\u1f0b\u0003", + "\u0002\u0002\u0002\u03d0\u1f0f\u0003\u0002\u0002\u0002\u03d2\u1f19\u0003", + "\u0002\u0002\u0002\u03d4\u1f1d\u0003\u0002\u0002\u0002\u03d6\u1f2d\u0003", + "\u0002\u0002\u0002\u03d8\u1f31\u0003\u0002\u0002\u0002\u03da\u1f36\u0003", + "\u0002\u0002\u0002\u03dc\u1f38\u0003\u0002\u0002\u0002\u03de\u1f42\u0003", + "\u0002\u0002\u0002\u03e0\u1f46\u0003\u0002\u0002\u0002\u03e2\u1f48\u0003", + "\u0002\u0002\u0002\u03e4\u1f4c\u0003\u0002\u0002\u0002\u03e6\u1f54\u0003", + "\u0002\u0002\u0002\u03e8\u1f64\u0003\u0002\u0002\u0002\u03ea\u1f68\u0003", + "\u0002\u0002\u0002\u03ec\u1f81\u0003\u0002\u0002\u0002\u03ee\u1f83\u0003", + "\u0002\u0002\u0002\u03f0\u1f8c\u0003\u0002\u0002\u0002\u03f2\u1f8e\u0003", + "\u0002\u0002\u0002\u03f4\u1f95\u0003\u0002\u0002\u0002\u03f6\u1f99\u0003", + "\u0002\u0002\u0002\u03f8\u1f9b\u0003\u0002\u0002\u0002\u03fa\u1f9d\u0003", + "\u0002\u0002\u0002\u03fc\u1fa3\u0003\u0002\u0002\u0002\u03fe\u1fa5\u0003", + "\u0002\u0002\u0002\u0400\u1fb2\u0003\u0002\u0002\u0002\u0402\u1fb4\u0003", + "\u0002\u0002\u0002\u0404\u1fb7\u0003\u0002\u0002\u0002\u0406\u1fbc\u0003", + "\u0002\u0002\u0002\u0408\u1fc1\u0003\u0002\u0002\u0002\u040a\u1fca\u0003", + "\u0002\u0002\u0002\u040c\u1fd0\u0003\u0002\u0002\u0002\u040e\u1fd4\u0003", + "\u0002\u0002\u0002\u0410\u1fd7\u0003\u0002\u0002\u0002\u0412\u1fdb\u0003", + "\u0002\u0002\u0002\u0414\u1fdf\u0003\u0002\u0002\u0002\u0416\u1fee\u0003", + "\u0002\u0002\u0002\u0418\u1ff0\u0003\u0002\u0002\u0002\u041a\u2001\u0003", + "\u0002\u0002\u0002\u041c\u2003\u0003\u0002\u0002\u0002\u041e\u203c\u0003", + "\u0002\u0002\u0002\u0420\u2054\u0003\u0002\u0002\u0002\u0422\u205f\u0003", + "\u0002\u0002\u0002\u0424\u206e\u0003\u0002\u0002\u0002\u0426\u2070\u0003", + "\u0002\u0002\u0002\u0428\u207b\u0003\u0002\u0002\u0002\u042a\u2089\u0003", + "\u0002\u0002\u0002\u042c\u208b\u0003\u0002\u0002\u0002\u042e\u2093\u0003", + "\u0002\u0002\u0002\u0430\u209a\u0003\u0002\u0002\u0002\u0432\u20a7\u0003", + "\u0002\u0002\u0002\u0434\u20b3\u0003\u0002\u0002\u0002\u0436\u20b5\u0003", + "\u0002\u0002\u0002\u0438\u20b8\u0003\u0002\u0002\u0002\u043a\u20c6\u0003", + "\u0002\u0002\u0002\u043c\u20cb\u0003\u0002\u0002\u0002\u043e\u20d0\u0003", + "\u0002\u0002\u0002\u0440\u20da\u0003\u0002\u0002\u0002\u0442\u20de\u0003", + "\u0002\u0002\u0002\u0444\u20e0\u0003\u0002\u0002\u0002\u0446\u20e8\u0003", + "\u0002\u0002\u0002\u0448\u20ec\u0003\u0002\u0002\u0002\u044a\u2101\u0003", + "\u0002\u0002\u0002\u044c\u2109\u0003\u0002\u0002\u0002\u044e\u2113\u0003", + "\u0002\u0002\u0002\u0450\u211f\u0003\u0002\u0002\u0002\u0452\u2121\u0003", + "\u0002\u0002\u0002\u0454\u212f\u0003\u0002\u0002\u0002\u0456\u2143\u0003", + "\u0002\u0002\u0002\u0458\u214c\u0003\u0002\u0002\u0002\u045a\u215c\u0003", + "\u0002\u0002\u0002\u045c\u2162\u0003\u0002\u0002\u0002\u045e\u2164\u0003", + "\u0002\u0002\u0002\u0460\u216f\u0003\u0002\u0002\u0002\u0462\u2181\u0003", + "\u0002\u0002\u0002\u0464\u2188\u0003\u0002\u0002\u0002\u0466\u218c\u0003", + "\u0002\u0002\u0002\u0468\u2190\u0003\u0002\u0002\u0002\u046a\u2192\u0003", + "\u0002\u0002\u0002\u046c\u2198\u0003\u0002\u0002\u0002\u046e\u219b\u0003", + "\u0002\u0002\u0002\u0470\u21a2\u0003\u0002\u0002\u0002\u0472\u21af\u0003", + "\u0002\u0002\u0002\u0474\u21b3\u0003\u0002\u0002\u0002\u0476\u21b5\u0003", + "\u0002\u0002\u0002\u0478\u21be\u0003\u0002\u0002\u0002\u047a\u21c7\u0003", + "\u0002\u0002\u0002\u047c\u21e3\u0003\u0002\u0002\u0002\u047e\u21e5\u0003", + "\u0002\u0002\u0002\u0480\u21ef\u0003\u0002\u0002\u0002\u0482\u21f1\u0003", + "\u0002\u0002\u0002\u0484\u21f3\u0003\u0002\u0002\u0002\u0486\u21f7\u0003", + "\u0002\u0002\u0002\u0488\u21ff\u0003\u0002\u0002\u0002\u048a\u2207\u0003", + "\u0002\u0002\u0002\u048c\u220f\u0003\u0002\u0002\u0002\u048e\u2218\u0003", + "\u0002\u0002\u0002\u0490\u221c\u0003\u0002\u0002\u0002\u0492\u2220\u0003", + "\u0002\u0002\u0002\u0494\u223a\u0003\u0002\u0002\u0002\u0496\u2248\u0003", + "\u0002\u0002\u0002\u0498\u225b\u0003\u0002\u0002\u0002\u049a\u2265\u0003", + "\u0002\u0002\u0002\u049c\u2269\u0003\u0002\u0002\u0002\u049e\u2271\u0003", + "\u0002\u0002\u0002\u04a0\u2279\u0003\u0002\u0002\u0002\u04a2\u227f\u0003", + "\u0002\u0002\u0002\u04a4\u2283\u0003\u0002\u0002\u0002\u04a6\u228a\u0003", + "\u0002\u0002\u0002\u04a8\u228f\u0003\u0002\u0002\u0002\u04aa\u229e\u0003", + "\u0002\u0002\u0002\u04ac\u22ee\u0003\u0002\u0002\u0002\u04ae\u22f0\u0003", + "\u0002\u0002\u0002\u04b0\u22f2\u0003\u0002\u0002\u0002\u04b2\u2310\u0003", + "\u0002\u0002\u0002\u04b4\u2314\u0003\u0002\u0002\u0002\u04b6\u23c7\u0003", + "\u0002\u0002\u0002\u04b8\u23ce\u0003\u0002\u0002\u0002\u04ba\u23db\u0003", + "\u0002\u0002\u0002\u04bc\u23dd\u0003\u0002\u0002\u0002\u04be\u23e2\u0003", + "\u0002\u0002\u0002\u04c0\u23ea\u0003\u0002\u0002\u0002\u04c2\u23ef\u0003", + "\u0002\u0002\u0002\u04c4\u23f6\u0003\u0002\u0002\u0002\u04c6\u2407\u0003", + "\u0002\u0002\u0002\u04c8\u2409\u0003\u0002\u0002\u0002\u04ca\u2413\u0003", + "\u0002\u0002\u0002\u04cc\u241c\u0003\u0002\u0002\u0002\u04ce\u2421\u0003", + "\u0002\u0002\u0002\u04d0\u2423\u0003\u0002\u0002\u0002\u04d2\u242b\u0003", + "\u0002\u0002\u0002\u04d4\u2435\u0003\u0002\u0002\u0002\u04d6\u2437\u0003", + "\u0002\u0002\u0002\u04d8\u2440\u0003\u0002\u0002\u0002\u04da\u2446\u0003", + "\u0002\u0002\u0002\u04dc\u2455\u0003\u0002\u0002\u0002\u04de\u245d\u0003", + "\u0002\u0002\u0002\u04e0\u2466\u0003\u0002\u0002\u0002\u04e2\u2472\u0003", + "\u0002\u0002\u0002\u04e4\u2480\u0003\u0002\u0002\u0002\u04e6\u2482\u0003", + "\u0002\u0002\u0002\u04e8\u2489\u0003\u0002\u0002\u0002\u04ea\u248f\u0003", + "\u0002\u0002\u0002\u04ec\u2493\u0003\u0002\u0002\u0002\u04ee\u2495\u0003", + "\u0002\u0002\u0002\u04f0\u249d\u0003\u0002\u0002\u0002\u04f2\u24a5\u0003", + "\u0002\u0002\u0002\u04f4\u24b3\u0003\u0002\u0002\u0002\u04f6\u24b5\u0003", + "\u0002\u0002\u0002\u04f8\u24bd\u0003\u0002\u0002\u0002\u04fa\u24ca\u0003", + "\u0002\u0002\u0002\u04fc\u24cc\u0003\u0002\u0002\u0002\u04fe\u24d4\u0003", + "\u0002\u0002\u0002\u0500\u24db\u0003\u0002\u0002\u0002\u0502\u24e8\u0003", + "\u0002\u0002\u0002\u0504\u24f2\u0003\u0002\u0002\u0002\u0506\u24f4\u0003", + "\u0002\u0002\u0002\u0508\u24f6\u0003\u0002\u0002\u0002\u050a\u2504\u0003", + "\u0002\u0002\u0002\u050c\u2522\u0003\u0002\u0002\u0002\u050e\u252b\u0003", + "\u0002\u0002\u0002\u0510\u2532\u0003\u0002\u0002\u0002\u0512\u2534\u0003", + "\u0002\u0002\u0002\u0514\u253b\u0003\u0002\u0002\u0002\u0516\u253f\u0003", + "\u0002\u0002\u0002\u0518\u2547\u0003\u0002\u0002\u0002\u051a\u254b\u0003", + "\u0002\u0002\u0002\u051c\u254d\u0003\u0002\u0002\u0002\u051e\u2560\u0003", + "\u0002\u0002\u0002\u0520\u2564\u0003\u0002\u0002\u0002\u0522\u2567\u0003", + "\u0002\u0002\u0002\u0524\u256e\u0003\u0002\u0002\u0002\u0526\u2573\u0003", + "\u0002\u0002\u0002\u0528\u2575\u0003\u0002\u0002\u0002\u052a\u2585\u0003", + "\u0002\u0002\u0002\u052c\u2587\u0003\u0002\u0002\u0002\u052e\u258f\u0003", + "\u0002\u0002\u0002\u0530\u2593\u0003\u0002\u0002\u0002\u0532\u259b\u0003", + "\u0002\u0002\u0002\u0534\u259d\u0003\u0002\u0002\u0002\u0536\u259f\u0003", + "\u0002\u0002\u0002\u0538\u25a5\u0003\u0002\u0002\u0002\u053a\u25c7\u0003", + "\u0002\u0002\u0002\u053c\u25c9\u0003\u0002\u0002\u0002\u053e\u25cb\u0003", + "\u0002\u0002\u0002\u0540\u25cd\u0003\u0002\u0002\u0002\u0542\u25cf\u0003", + "\u0002\u0002\u0002\u0544\u25d1\u0003\u0002\u0002\u0002\u0546\u25df\u0003", + "\u0002\u0002\u0002\u0548\u25e4\u0003\u0002\u0002\u0002\u054a\u25eb\u0003", + "\u0002\u0002\u0002\u054c\u25ed\u0003\u0002\u0002\u0002\u054e\u25f2\u0003", + "\u0002\u0002\u0002\u0550\u25f4\u0003\u0002\u0002\u0002\u0552\u2600\u0003", + "\u0002\u0002\u0002\u0554\u2606\u0003\u0002\u0002\u0002\u0556\u260c\u0003", + "\u0002\u0002\u0002\u0558\u2614\u0003\u0002\u0002\u0002\u055a\u261d\u0003", + "\u0002\u0002\u0002\u055c\u261f\u0003\u0002\u0002\u0002\u055e\u2621\u0003", + "\u0002\u0002\u0002\u0560\u2656\u0003\u0002\u0002\u0002\u0562\u2658\u0003", + "\u0002\u0002\u0002\u0564\u265a\u0003\u0002\u0002\u0002\u0566\u265c\u0003", + "\u0002\u0002\u0002\u0568\u2663\u0003\u0002\u0002\u0002\u056a\u267a\u0003", + "\u0002\u0002\u0002\u056c\u267c\u0003\u0002\u0002\u0002\u056e\u2682\u0003", + "\u0002\u0002\u0002\u0570\u2686\u0003\u0002\u0002\u0002\u0572\u2688\u0003", + "\u0002\u0002\u0002\u0574\u268f\u0003\u0002\u0002\u0002\u0576\u2696\u0003", + "\u0002\u0002\u0002\u0578\u2699\u0003\u0002\u0002\u0002\u057a\u269d\u0003", + "\u0002\u0002\u0002\u057c\u26a4\u0003\u0002\u0002\u0002\u057e\u26a6\u0003", + "\u0002\u0002\u0002\u0580\u26be\u0003\u0002\u0002\u0002\u0582\u26c0\u0003", + "\u0002\u0002\u0002\u0584\u26c7\u0003\u0002\u0002\u0002\u0586\u26c9\u0003", + "\u0002\u0002\u0002\u0588\u26d1\u0003\u0002\u0002\u0002\u058a\u26d4\u0003", + "\u0002\u0002\u0002\u058c\u26d8\u0003\u0002\u0002\u0002\u058e\u26da\u0003", + "\u0002\u0002\u0002\u0590\u26de\u0003\u0002\u0002\u0002\u0592\u26e0\u0003", + "\u0002\u0002\u0002\u0594\u26e5\u0003\u0002\u0002\u0002\u0596\u26ea\u0003", + "\u0002\u0002\u0002\u0598\u26f0\u0003\u0002\u0002\u0002\u059a\u26f4\u0003", + "\u0002\u0002\u0002\u059c\u26f6\u0003\u0002\u0002\u0002\u059e\u26fb\u0003", + "\u0002\u0002\u0002\u05a0\u2719\u0003\u0002\u0002\u0002\u05a2\u271b\u0003", + "\u0002\u0002\u0002\u05a4\u272d\u0003\u0002\u0002\u0002\u05a6\u2731\u0003", + "\u0002\u0002\u0002\u05a8\u2733\u0003\u0002\u0002\u0002\u05aa\u2738\u0003", + "\u0002\u0002\u0002\u05ac\u2741\u0003\u0002\u0002\u0002\u05ae\u2743\u0003", + "\u0002\u0002\u0002\u05b0\u274b\u0003\u0002\u0002\u0002\u05b2\u274f\u0003", + "\u0002\u0002\u0002\u05b4\u2751\u0003\u0002\u0002\u0002\u05b6\u2755\u0003", + "\u0002\u0002\u0002\u05b8\u2760\u0003\u0002\u0002\u0002\u05ba\u2771\u0003", + "\u0002\u0002\u0002\u05bc\u2777\u0003\u0002\u0002\u0002\u05be\u2779\u0003", + "\u0002\u0002\u0002\u05c0\u2783\u0003\u0002\u0002\u0002\u05c2\u2786\u0003", + "\u0002\u0002\u0002\u05c4\u278a\u0003\u0002\u0002\u0002\u05c6\u2792\u0003", + "\u0002\u0002\u0002\u05c8\u2794\u0003\u0002\u0002\u0002\u05ca\u2797\u0003", + "\u0002\u0002\u0002\u05cc\u279c\u0003\u0002\u0002\u0002\u05ce\u27a1\u0003", + "\u0002\u0002\u0002\u05d0\u27b7\u0003\u0002\u0002\u0002\u05d2\u27c5\u0003", + "\u0002\u0002\u0002\u05d4\u27c9\u0003\u0002\u0002\u0002\u05d6\u27ce\u0003", + "\u0002\u0002\u0002\u05d8\u27d0\u0003\u0002\u0002\u0002\u05da\u27d2\u0003", + "\u0002\u0002\u0002\u05dc\u27de\u0003\u0002\u0002\u0002\u05de\u27e0\u0003", + "\u0002\u0002\u0002\u05e0\u27e5\u0003\u0002\u0002\u0002\u05e2\u27e7\u0003", + "\u0002\u0002\u0002\u05e4\u27f9\u0003\u0002\u0002\u0002\u05e6\u2815\u0003", + "\u0002\u0002\u0002\u05e8\u281f\u0003\u0002\u0002\u0002\u05ea\u2828\u0003", + "\u0002\u0002\u0002\u05ec\u282d\u0003\u0002\u0002\u0002\u05ee\u282f\u0003", + "\u0002\u0002\u0002\u05f0\u2833\u0003\u0002\u0002\u0002\u05f2\u283b\u0003", + "\u0002\u0002\u0002\u05f4\u2843\u0003\u0002\u0002\u0002\u05f6\u2845\u0003", + "\u0002\u0002\u0002\u05f8\u284c\u0003\u0002\u0002\u0002\u05fa\u284f\u0003", + "\u0002\u0002\u0002\u05fc\u285f\u0003\u0002\u0002\u0002\u05fe\u2861\u0003", + "\u0002\u0002\u0002\u0600\u286f\u0003\u0002\u0002\u0002\u0602\u2871\u0003", + "\u0002\u0002\u0002\u0604\u288c\u0003\u0002\u0002\u0002\u0606\u288e\u0003", + "\u0002\u0002\u0002\u0608\u2899\u0003\u0002\u0002\u0002\u060a\u289f\u0003", + "\u0002\u0002\u0002\u060c\u28a3\u0003\u0002\u0002\u0002\u060e\u28a5\u0003", + "\u0002\u0002\u0002\u0610\u28ad\u0003\u0002\u0002\u0002\u0612\u28b2\u0003", + "\u0002\u0002\u0002\u0614\u28c5\u0003\u0002\u0002\u0002\u0616\u28c7\u0003", + "\u0002\u0002\u0002\u0618\u28cc\u0003\u0002\u0002\u0002\u061a\u28d0\u0003", + "\u0002\u0002\u0002\u061c\u28d3\u0003\u0002\u0002\u0002\u061e\u28d7\u0003", + "\u0002\u0002\u0002\u0620\u28e1\u0003\u0002\u0002\u0002\u0622\u28ef\u0003", + "\u0002\u0002\u0002\u0624\u28f3\u0003\u0002\u0002\u0002\u0626\u28f8\u0003", + "\u0002\u0002\u0002\u0628\u28fb\u0003\u0002\u0002\u0002\u062a\u28ff\u0003", + "\u0002\u0002\u0002\u062c\u2904\u0003\u0002\u0002\u0002\u062e\u290f\u0003", + "\u0002\u0002\u0002\u0630\u2913\u0003\u0002\u0002\u0002\u0632\u2917\u0003", + "\u0002\u0002\u0002\u0634\u291b\u0003\u0002\u0002\u0002\u0636\u2920\u0003", + "\u0002\u0002\u0002\u0638\u2924\u0003\u0002\u0002\u0002\u063a\u2926\u0003", + "\u0002\u0002\u0002\u063c\u2928\u0003\u0002\u0002\u0002\u063e\u2930\u0003", + "\u0002\u0002\u0002\u0640\u2932\u0003\u0002\u0002\u0002\u0642\u2934\u0003", + "\u0002\u0002\u0002\u0644\u2936\u0003\u0002\u0002\u0002\u0646\u2938\u0003", + "\u0002\u0002\u0002\u0648\u2940\u0003\u0002\u0002\u0002\u064a\u064b\u0005", + "\u0006\u0004\u0002\u064b\u064c\u0007\u0002\u0002\u0003\u064c\u0003\u0003", + "\u0002\u0002\u0002\u064d\u064e\u0005\u0566\u02b4\u0002\u064e\u0005\u0003", + "\u0002\u0002\u0002\u064f\u0650\u0005\b\u0005\u0002\u0650\u0007\u0003", + "\u0002\u0002\u0002\u0651\u0653\u0005\n\u0006\u0002\u0652\u0654\u0007", + "\t\u0002\u0002\u0653\u0652\u0003\u0002\u0002\u0002\u0653\u0654\u0003", + "\u0002\u0002\u0002\u0654\u0656\u0003\u0002\u0002\u0002\u0655\u0651\u0003", + "\u0002\u0002\u0002\u0656\u0659\u0003\u0002\u0002\u0002\u0657\u0655\u0003", + "\u0002\u0002\u0002\u0657\u0658\u0003\u0002\u0002\u0002\u0658\t\u0003", + "\u0002\u0002\u0002\u0659\u0657\u0003\u0002\u0002\u0002\u065a\u06d7\u0005", + "\u01c6\u00e4\u0002\u065b\u06d7\u0005\u033c\u019f\u0002\u065c\u06d7\u0005", + "\u0332\u019a\u0002\u065d\u06d7\u0005\u0334\u019b\u0002\u065e\u06d7\u0005", + "\u0244\u0123\u0002\u065f\u06d7\u0005\u0342\u01a2\u0002\u0660\u06d7\u0005", + "\u01e0\u00f1\u0002\u0661\u06d7\u0005\u0144\u00a3\u0002\u0662\u06d7\u0005", + "\u014a\u00a6\u0002\u0663\u06d7\u0005\u0154\u00ab\u0002\u0664\u06d7\u0005", + "\u016e\u00b8\u0002\u0665\u06d7\u0005\u02a0\u0151\u0002\u0666\u06d7\u0005", + "(\u0015\u0002\u0667\u06d7\u0005\u02da\u016e\u0002\u0668\u06d7\u0005", + "\u02de\u0170\u0002\u0669\u06d7\u0005\u02ea\u0176\u0002\u066a\u06d7\u0005", + "\u02e0\u0171\u0002\u066b\u06d7\u0005\u02e8\u0175\u0002\u066c\u06d7\u0005", + "\u0182\u00c2\u0002\u066d\u06d7\u0005\u011a\u008e\u0002\u066e\u06d7\u0005", + "\u033e\u01a0\u0002\u066f\u06d7\u0005b2\u0002\u0670\u06d7\u0005\u02d2", + "\u016a\u0002\u0671\u06d7\u0005\u0088E\u0002\u0672\u06d7\u0005\u02f2", + "\u017a\u0002\u0673\u06d7\u0005\"\u0012\u0002\u0674\u06d7\u0005\u001e", + "\u0010\u0002\u0675\u06d7\u0005\u02fa\u017e\u0002\u0676\u06d7\u0005\u0108", + "\u0085\u0002\u0677\u06d7\u0005\u0348\u01a5\u0002\u0678\u06d7\u0005\u0346", + "\u01a4\u0002\u0679\u06d7\u0005\u017e\u00c0\u0002\u067a\u06d7\u0005\u0354", + "\u01ab\u0002\u067b\u06d7\u0005\u000e\b\u0002\u067c\u06d7\u0005^0\u0002", + "\u067d\u06d7\u0005\u008eH\u0002\u067e\u06d7\u0005\u034e\u01a8\u0002", + "\u067f\u06d7\u0005\u0218\u010d\u0002\u0680\u06d7\u0005X-\u0002\u0681", + "\u06d7\u0005\u0090I\u0002\u0682\u06d7\u0005\u0192\u00ca\u0002\u0683", + "\u06d7\u0005\u010a\u0086\u0002\u0684\u06d7\u0005\u01ca\u00e6\u0002\u0685", + "\u06d7\u0005\u02ba\u015e\u0002\u0686\u06d7\u0005\u034c\u01a7\u0002\u0687", + "\u06d7\u0005\u0340\u01a1\u0002\u0688\u06d7\u0005\u013e\u00a0\u0002\u0689", + "\u06d7\u0005\u014c\u00a7\u0002\u068a\u06d7\u0005\u0166\u00b4\u0002\u068b", + "\u06d7\u0005\u0170\u00b9\u0002\u068c\u06d7\u0005\u026a\u0136\u0002\u068d", + "\u06d7\u0005&\u0014\u0002\u068e\u06d7\u0005\u0110\u0089\u0002\u068f", + "\u06d7\u0005\u01e4\u00f3\u0002\u0690\u06d7\u0005\u01f2\u00fa\u0002\u0691", + "\u06d7\u0005\u02ec\u0177\u0002\u0692\u06d7\u0005\u01f4\u00fb\u0002\u0693", + "\u06d7\u0005\u0180\u00c1\u0002\u0694\u06d7\u0005\u012a\u0096\u0002\u0695", + "\u06d7\u0005,\u0017\u0002\u0696\u06d7\u0005\u0118\u008d\u0002\u0697", + "\u06d7\u0005\u00aeX\u0002\u0698\u06d7\u0005\u02f4\u017b\u0002\u0699", + "\u06d7\u0005\u0106\u0084\u0002\u069a\u06d7\u0005\u0138\u009d\u0002\u069b", + "\u06d7\u0005\u02c2\u0162\u0002\u069c\u06d7\u0005\u0196\u00cc\u0002\u069d", + "\u06d7\u0005\u01be\u00e0\u0002\u069e\u06d7\u0005\u0010\t\u0002\u069f", + "\u06d7\u0005\u001c\u000f\u0002\u06a0\u06d7\u0005\u0178\u00bd\u0002\u06a1", + "\u06d7\u0005\u0326\u0194\u0002\u06a2\u06d7\u0005\u0386\u01c4\u0002\u06a3", + "\u06d7\u0005\u03b2\u01da\u0002\u06a4\u06d7\u0005\u01cc\u00e7\u0002\u06a5", + "\u06d7\u0005\u039a\u01ce\u0002\u06a6\u06d7\u0005`1\u0002\u06a7\u06d7", + "\u0005\u02b4\u015b\u0002\u06a8\u06d7\u0005\u02be\u0160\u0002\u06a9\u06d7", + "\u0005\u01fa\u00fe\u0002\u06aa\u06d7\u0005\u01fc\u00ff\u0002\u06ab\u06d7", + "\u0005\u01fe\u0100\u0002\u06ac\u06d7\u0005\u0202\u0102\u0002\u06ad\u06d7", + "\u0005\u02fc\u017f\u0002\u06ae\u06d7\u0005\u013c\u009f\u0002\u06af\u06d7", + "\u0005\u02c6\u0164\u0002\u06b0\u06d7\u0005$\u0013\u0002\u06b1\u06d7", + "\u0005\u017c\u00bf\u0002\u06b2\u06d7\u0005\u0336\u019c\u0002\u06b3\u06d7", + "\u0005\u0382\u01c2\u0002\u06b4\u06d7\u0005\u0370\u01b9\u0002\u06b5\u06d7", + "\u0005\u0222\u0112\u0002\u06b6\u06d7\u0005\u022a\u0116\u0002\u06b7\u06d7", + "\u0005\u023c\u011f\u0002\u06b8\u06d7\u0005\u0172\u00ba\u0002\u06b9\u06d7", + "\u0005\u024e\u0128\u0002\u06ba\u06d7\u0005\u0388\u01c5\u0002\u06bb\u06d7", + "\u0005\u0310\u0189\u0002\u06bc\u06d7\u0005\u0116\u008c\u0002\u06bd\u06d7", + "\u0005\u0324\u0193\u0002\u06be\u06d7\u0005\u039e\u01d0\u0002\u06bf\u06d7", + "\u0005\u030c\u0187\u0002\u06c0\u06d7\u0005\u037c\u01bf\u0002\u06c1\u06d7", + "\u0005\u0200\u0101\u0002\u06c2\u06d7\u0005\u02c8\u0165\u0002\u06c3\u06d7", + "\u0005\u02a8\u0155\u0002\u06c4\u06d7\u0005\u02a6\u0154\u0002\u06c5\u06d7", + "\u0005\u02aa\u0156\u0002\u06c6\u06d7\u0005\u02d4\u016b\u0002\u06c7\u06d7", + "\u0005\u022c\u0117\u0002\u06c8\u06d7\u0005\u023e\u0120\u0002\u06c9\u06d7", + "\u0005\u02fe\u0180\u0002\u06ca\u06d7\u0005\u021c\u010f\u0002\u06cb\u06d7", + "\u0005\u03ba\u01de\u0002\u06cc\u06d7\u0005\u0314\u018b\u0002\u06cd\u06d7", + "\u0005\u0214\u010b\u0002\u06ce\u06d7\u0005\u0312\u018a\u0002\u06cf\u06d7", + "\u0005\u03a8\u01d5\u0002\u06d0\u06d7\u0005\u0352\u01aa\u0002\u06d1\u06d7", + "\u0005L\'\u0002\u06d2\u06d7\u00054\u001b\u0002\u06d3\u06d7\u0005V,\u0002", + "\u06d4\u06d7\u0005\u0320\u0191\u0002\u06d5\u06d7\u0005\f\u0007\u0002", + "\u06d6\u065a\u0003\u0002\u0002\u0002\u06d6\u065b\u0003\u0002\u0002\u0002", + "\u06d6\u065c\u0003\u0002\u0002\u0002\u06d6\u065d\u0003\u0002\u0002\u0002", + "\u06d6\u065e\u0003\u0002\u0002\u0002\u06d6\u065f\u0003\u0002\u0002\u0002", + "\u06d6\u0660\u0003\u0002\u0002\u0002\u06d6\u0661\u0003\u0002\u0002\u0002", + "\u06d6\u0662\u0003\u0002\u0002\u0002\u06d6\u0663\u0003\u0002\u0002\u0002", + "\u06d6\u0664\u0003\u0002\u0002\u0002\u06d6\u0665\u0003\u0002\u0002\u0002", + "\u06d6\u0666\u0003\u0002\u0002\u0002\u06d6\u0667\u0003\u0002\u0002\u0002", + "\u06d6\u0668\u0003\u0002\u0002\u0002\u06d6\u0669\u0003\u0002\u0002\u0002", + "\u06d6\u066a\u0003\u0002\u0002\u0002\u06d6\u066b\u0003\u0002\u0002\u0002", + "\u06d6\u066c\u0003\u0002\u0002\u0002\u06d6\u066d\u0003\u0002\u0002\u0002", + "\u06d6\u066e\u0003\u0002\u0002\u0002\u06d6\u066f\u0003\u0002\u0002\u0002", + "\u06d6\u0670\u0003\u0002\u0002\u0002\u06d6\u0671\u0003\u0002\u0002\u0002", + "\u06d6\u0672\u0003\u0002\u0002\u0002\u06d6\u0673\u0003\u0002\u0002\u0002", + "\u06d6\u0674\u0003\u0002\u0002\u0002\u06d6\u0675\u0003\u0002\u0002\u0002", + "\u06d6\u0676\u0003\u0002\u0002\u0002\u06d6\u0677\u0003\u0002\u0002\u0002", + "\u06d6\u0678\u0003\u0002\u0002\u0002\u06d6\u0679\u0003\u0002\u0002\u0002", + "\u06d6\u067a\u0003\u0002\u0002\u0002\u06d6\u067b\u0003\u0002\u0002\u0002", + "\u06d6\u067c\u0003\u0002\u0002\u0002\u06d6\u067d\u0003\u0002\u0002\u0002", + "\u06d6\u067e\u0003\u0002\u0002\u0002\u06d6\u067f\u0003\u0002\u0002\u0002", + "\u06d6\u0680\u0003\u0002\u0002\u0002\u06d6\u0681\u0003\u0002\u0002\u0002", + "\u06d6\u0682\u0003\u0002\u0002\u0002\u06d6\u0683\u0003\u0002\u0002\u0002", + "\u06d6\u0684\u0003\u0002\u0002\u0002\u06d6\u0685\u0003\u0002\u0002\u0002", + "\u06d6\u0686\u0003\u0002\u0002\u0002\u06d6\u0687\u0003\u0002\u0002\u0002", + "\u06d6\u0688\u0003\u0002\u0002\u0002\u06d6\u0689\u0003\u0002\u0002\u0002", + "\u06d6\u068a\u0003\u0002\u0002\u0002\u06d6\u068b\u0003\u0002\u0002\u0002", + "\u06d6\u068c\u0003\u0002\u0002\u0002\u06d6\u068d\u0003\u0002\u0002\u0002", + "\u06d6\u068e\u0003\u0002\u0002\u0002\u06d6\u068f\u0003\u0002\u0002\u0002", + "\u06d6\u0690\u0003\u0002\u0002\u0002\u06d6\u0691\u0003\u0002\u0002\u0002", + "\u06d6\u0692\u0003\u0002\u0002\u0002\u06d6\u0693\u0003\u0002\u0002\u0002", + "\u06d6\u0694\u0003\u0002\u0002\u0002\u06d6\u0695\u0003\u0002\u0002\u0002", + "\u06d6\u0696\u0003\u0002\u0002\u0002\u06d6\u0697\u0003\u0002\u0002\u0002", + "\u06d6\u0698\u0003\u0002\u0002\u0002\u06d6\u0699\u0003\u0002\u0002\u0002", + "\u06d6\u069a\u0003\u0002\u0002\u0002\u06d6\u069b\u0003\u0002\u0002\u0002", + "\u06d6\u069c\u0003\u0002\u0002\u0002\u06d6\u069d\u0003\u0002\u0002\u0002", + "\u06d6\u069e\u0003\u0002\u0002\u0002\u06d6\u069f\u0003\u0002\u0002\u0002", + "\u06d6\u06a0\u0003\u0002\u0002\u0002\u06d6\u06a1\u0003\u0002\u0002\u0002", + "\u06d6\u06a2\u0003\u0002\u0002\u0002\u06d6\u06a3\u0003\u0002\u0002\u0002", + "\u06d6\u06a4\u0003\u0002\u0002\u0002\u06d6\u06a5\u0003\u0002\u0002\u0002", + "\u06d6\u06a6\u0003\u0002\u0002\u0002\u06d6\u06a7\u0003\u0002\u0002\u0002", + "\u06d6\u06a8\u0003\u0002\u0002\u0002\u06d6\u06a9\u0003\u0002\u0002\u0002", + "\u06d6\u06aa\u0003\u0002\u0002\u0002\u06d6\u06ab\u0003\u0002\u0002\u0002", + "\u06d6\u06ac\u0003\u0002\u0002\u0002\u06d6\u06ad\u0003\u0002\u0002\u0002", + "\u06d6\u06ae\u0003\u0002\u0002\u0002\u06d6\u06af\u0003\u0002\u0002\u0002", + "\u06d6\u06b0\u0003\u0002\u0002\u0002\u06d6\u06b1\u0003\u0002\u0002\u0002", + "\u06d6\u06b2\u0003\u0002\u0002\u0002\u06d6\u06b3\u0003\u0002\u0002\u0002", + "\u06d6\u06b4\u0003\u0002\u0002\u0002\u06d6\u06b5\u0003\u0002\u0002\u0002", + "\u06d6\u06b6\u0003\u0002\u0002\u0002\u06d6\u06b7\u0003\u0002\u0002\u0002", + "\u06d6\u06b8\u0003\u0002\u0002\u0002\u06d6\u06b9\u0003\u0002\u0002\u0002", + "\u06d6\u06ba\u0003\u0002\u0002\u0002\u06d6\u06bb\u0003\u0002\u0002\u0002", + "\u06d6\u06bc\u0003\u0002\u0002\u0002\u06d6\u06bd\u0003\u0002\u0002\u0002", + "\u06d6\u06be\u0003\u0002\u0002\u0002\u06d6\u06bf\u0003\u0002\u0002\u0002", + "\u06d6\u06c0\u0003\u0002\u0002\u0002\u06d6\u06c1\u0003\u0002\u0002\u0002", + "\u06d6\u06c2\u0003\u0002\u0002\u0002\u06d6\u06c3\u0003\u0002\u0002\u0002", + "\u06d6\u06c4\u0003\u0002\u0002\u0002\u06d6\u06c5\u0003\u0002\u0002\u0002", + "\u06d6\u06c6\u0003\u0002\u0002\u0002\u06d6\u06c7\u0003\u0002\u0002\u0002", + "\u06d6\u06c8\u0003\u0002\u0002\u0002\u06d6\u06c9\u0003\u0002\u0002\u0002", + "\u06d6\u06ca\u0003\u0002\u0002\u0002\u06d6\u06cb\u0003\u0002\u0002\u0002", + "\u06d6\u06cc\u0003\u0002\u0002\u0002\u06d6\u06cd\u0003\u0002\u0002\u0002", + "\u06d6\u06ce\u0003\u0002\u0002\u0002\u06d6\u06cf\u0003\u0002\u0002\u0002", + "\u06d6\u06d0\u0003\u0002\u0002\u0002\u06d6\u06d1\u0003\u0002\u0002\u0002", + "\u06d6\u06d2\u0003\u0002\u0002\u0002\u06d6\u06d3\u0003\u0002\u0002\u0002", + "\u06d6\u06d4\u0003\u0002\u0002\u0002\u06d6\u06d5\u0003\u0002\u0002\u0002", + "\u06d7\u000b\u0003\u0002\u0002\u0002\u06d8\u06da\u0007\u0222\u0002\u0002", + "\u06d9\u06db\u0007\u0223\u0002\u0002\u06da\u06d9\u0003\u0002\u0002\u0002", + "\u06da\u06db\u0003\u0002\u0002\u0002\u06db\r\u0003\u0002\u0002\u0002", + "\u06dc\u06dd\u0007\u01aa\u0002\u0002\u06dd\u06de\u0005\u04b0\u0259\u0002", + "\u06de\u000f\u0003\u0002\u0002\u0002\u06df\u06e0\u00070\u0002\u0002", + "\u06e0\u06e1\u0007\u0137\u0002\u0002\u06e1\u06e2\u0005\u054c\u02a7\u0002", + "\u06e2\u06e3\u0005\u0012\n\u0002\u06e3\u06e4\u0005\u0014\u000b\u0002", + "\u06e4\u0011\u0003\u0002\u0002\u0002\u06e5\u06e8\u0007k\u0002\u0002", + "\u06e6\u06e8\u0003\u0002\u0002\u0002\u06e7\u06e5\u0003\u0002\u0002\u0002", + "\u06e7\u06e6\u0003\u0002\u0002\u0002\u06e8\u0013\u0003\u0002\u0002\u0002", + "\u06e9\u06eb\u0005\u001a\u000e\u0002\u06ea\u06e9\u0003\u0002\u0002\u0002", + "\u06eb\u06ee\u0003\u0002\u0002\u0002\u06ec\u06ea\u0003\u0002\u0002\u0002", + "\u06ec\u06ed\u0003\u0002\u0002\u0002\u06ed\u0015\u0003\u0002\u0002\u0002", + "\u06ee\u06ec\u0003\u0002\u0002\u0002\u06ef\u06f1\u0005\u0018\r\u0002", + "\u06f0\u06ef\u0003\u0002\u0002\u0002\u06f1\u06f4\u0003\u0002\u0002\u0002", + "\u06f2\u06f0\u0003\u0002\u0002\u0002\u06f2\u06f3\u0003\u0002\u0002\u0002", + "\u06f3\u0017\u0003\u0002\u0002\u0002\u06f4\u06f2\u0003\u0002\u0002\u0002", + "\u06f5\u06f8\u0007\u0118\u0002\u0002\u06f6\u06f9\u0005\u0544\u02a3\u0002", + "\u06f7\u06f9\u0007P\u0002\u0002\u06f8\u06f6\u0003\u0002\u0002\u0002", + "\u06f8\u06f7\u0003\u0002\u0002\u0002\u06f9\u0708\u0003\u0002\u0002\u0002", + "\u06fa\u06fb\t\u0002\u0002\u0002\u06fb\u06fc\u0007\u0118\u0002\u0002", + "\u06fc\u0708\u0005\u0544\u02a3\u0002\u06fd\u0708\u0007\u00e6\u0002\u0002", + "\u06fe\u06ff\u0007\u00a6\u0002\u0002\u06ff\u0700\u0007L\u0002\u0002", + "\u0700\u0708\u0005\u054a\u02a6\u0002\u0701\u0702\u0007\u016c\u0002\u0002", + "\u0702\u0703\u0007\u0169\u0002\u0002\u0703\u0708\u0005\u0544\u02a3\u0002", + "\u0704\u0705\u0007e\u0002\u0002\u0705\u0708\u0005\u0550\u02a9\u0002", + "\u0706\u0708\u0005\u055a\u02ae\u0002\u0707\u06f5\u0003\u0002\u0002\u0002", + "\u0707\u06fa\u0003\u0002\u0002\u0002\u0707\u06fd\u0003\u0002\u0002\u0002", + "\u0707\u06fe\u0003\u0002\u0002\u0002\u0707\u0701\u0003\u0002\u0002\u0002", + "\u0707\u0704\u0003\u0002\u0002\u0002\u0707\u0706\u0003\u0002\u0002\u0002", + "\u0708\u0019\u0003\u0002\u0002\u0002\u0709\u0714\u0005\u0018\r\u0002", + "\u070a\u070b\u0007\u0155\u0002\u0002\u070b\u0714\u0005\u0542\u02a2\u0002", + "\u070c\u070d\u0007\u0088\u0002\u0002\u070d\u0714\u0005\u0550\u02a9\u0002", + "\u070e\u070f\u0007\u0137\u0002\u0002\u070f\u0714\u0005\u0550\u02a9\u0002", + "\u0710\u0711\u0007F\u0002\u0002\u0711\u0712\t\u0003\u0002\u0002\u0712", + "\u0714\u0005\u0550\u02a9\u0002\u0713\u0709\u0003\u0002\u0002\u0002\u0713", + "\u070a\u0003\u0002\u0002\u0002\u0713\u070c\u0003\u0002\u0002\u0002\u0713", + "\u070e\u0003\u0002\u0002\u0002\u0713\u0710\u0003\u0002\u0002\u0002\u0714", + "\u001b\u0003\u0002\u0002\u0002\u0715\u0716\u00070\u0002\u0002\u0716", + "\u0717\u0007e\u0002\u0002\u0717\u0718\u0005\u054c\u02a7\u0002\u0718", + "\u0719\u0005\u0012\n\u0002\u0719\u071a\u0005\u0014\u000b\u0002\u071a", + "\u001d\u0003\u0002\u0002\u0002\u071b\u071c\u0007\u008c\u0002\u0002\u071c", + "\u071d\t\u0004\u0002\u0002\u071d\u071e\u0005\u054e\u02a8\u0002\u071e", + "\u071f\u0005\u0012\n\u0002\u071f\u0720\u0005\u0016\f\u0002\u0720\u001f", + "\u0003\u0002\u0002\u0002\u0721\u0726\u0003\u0002\u0002\u0002\u0722\u0723", + "\u0007F\u0002\u0002\u0723\u0724\u0007\u00b1\u0002\u0002\u0724\u0726", + "\u0005\u0532\u029a\u0002\u0725\u0721\u0003\u0002\u0002\u0002\u0725\u0722", + "\u0003\u0002\u0002\u0002\u0726!\u0003\u0002\u0002\u0002\u0727\u0728", + "\u0007\u008c\u0002\u0002\u0728\u072a\t\u0004\u0002\u0002\u0729\u072b", + "\u0007 \u0002\u0002\u072a\u0729\u0003\u0002\u0002\u0002\u072a\u072b", + "\u0003\u0002\u0002\u0002\u072b\u072c\u0003\u0002\u0002\u0002\u072c\u072d", + "\u0005\u054e\u02a8\u0002\u072d\u072e\u0005 \u0011\u0002\u072e\u072f", + "\u0005R*\u0002\u072f#\u0003\u0002\u0002\u0002\u0730\u0731\u0007\u00c1", + "\u0002\u0002\u0731\u0734\t\u0005\u0002\u0002\u0732\u0733\u0007\u00de", + "\u0002\u0002\u0733\u0735\u0007\u0185\u0002\u0002\u0734\u0732\u0003\u0002", + "\u0002\u0002\u0734\u0735\u0003\u0002\u0002\u0002\u0735\u0736\u0003\u0002", + "\u0002\u0002\u0736\u0737\u0005\u0550\u02a9\u0002\u0737%\u0003\u0002", + "\u0002\u0002\u0738\u0739\u00070\u0002\u0002\u0739\u073a\u0007D\u0002", + "\u0002\u073a\u073b\u0005\u054c\u02a7\u0002\u073b\u073c\u0005\u0012\n", + "\u0002\u073c\u073d\u0005\u0014\u000b\u0002\u073d\'\u0003\u0002\u0002", + "\u0002\u073e\u073f\u0007\u008c\u0002\u0002\u073f\u0740\u0007D\u0002", + "\u0002\u0740\u0741\u0005\u054e\u02a8\u0002\u0741\u0742\u0005*\u0016", + "\u0002\u0742\u0743\u0007e\u0002\u0002\u0743\u0744\u0005\u0550\u02a9", + "\u0002\u0744)\u0003\u0002\u0002\u0002\u0745\u0746\t\u0006\u0002\u0002", + "\u0746+\u0003\u0002\u0002\u0002\u0747\u0748\u00070\u0002\u0002\u0748", + "\u074c\u0007\u013c\u0002\u0002\u0749\u074a\u0007\u00de\u0002\u0002\u074a", + "\u074b\u0007O\u0002\u0002\u074b\u074d\u0007\u0185\u0002\u0002\u074c", + "\u0749\u0003\u0002\u0002\u0002\u074c\u074d\u0003\u0002\u0002\u0002\u074d", + "\u0753\u0003\u0002\u0002\u0002\u074e\u074f\u0005.\u0018\u0002\u074f", + "\u0750\u0007l\u0002\u0002\u0750\u0751\u0005\u054e\u02a8\u0002\u0751", + "\u0754\u0003\u0002\u0002\u0002\u0752\u0754\u0005\u0552\u02aa\u0002\u0753", + "\u074e\u0003\u0002\u0002\u0002\u0753\u0752\u0003\u0002\u0002\u0002\u0754", + "\u0755\u0003\u0002\u0002\u0002\u0755\u0756\u00050\u0019\u0002\u0756", + "-\u0003\u0002\u0002\u0002\u0757\u075a\u0005\u0552\u02aa\u0002\u0758", + "\u075a\u0003\u0002\u0002\u0002\u0759\u0757\u0003\u0002\u0002\u0002\u0759", + "\u0758\u0003\u0002\u0002\u0002\u075a/\u0003\u0002\u0002\u0002\u075b", + "\u075d\u00052\u001a\u0002\u075c\u075b\u0003\u0002\u0002\u0002\u075d", + "\u0760\u0003\u0002\u0002\u0002\u075e\u075c\u0003\u0002\u0002\u0002\u075e", + "\u075f\u0003\u0002\u0002\u0002\u075f1\u0003\u0002\u0002\u0002\u0760", + "\u075e\u0003\u0002\u0002\u0002\u0761\u0768\u0005\u00aeX\u0002\u0762", + "\u0768\u0005\u024e\u0128\u0002\u0763\u0768\u0005\u0118\u008d\u0002\u0764", + "\u0768\u0005\u0196\u00cc\u0002\u0765\u0768\u0005\u022a\u0116\u0002\u0766", + "\u0768\u0005\u0320\u0191\u0002\u0767\u0761\u0003\u0002\u0002\u0002\u0767", + "\u0762\u0003\u0002\u0002\u0002\u0767\u0763\u0003\u0002\u0002\u0002\u0767", + "\u0764\u0003\u0002\u0002\u0002\u0767\u0765\u0003\u0002\u0002\u0002\u0767", + "\u0766\u0003\u0002\u0002\u0002\u07683\u0003\u0002\u0002\u0002\u0769", + "\u076b\u0007\u0146\u0002\u0002\u076a\u076c\t\u0007\u0002\u0002\u076b", + "\u076a\u0003\u0002\u0002\u0002\u076b\u076c\u0003\u0002\u0002\u0002\u076c", + "\u076d\u0003\u0002\u0002\u0002\u076d\u076e\u00056\u001c\u0002\u076e", + "5\u0003\u0002\u0002\u0002\u076f\u0770\u0007\u015d\u0002\u0002\u0770", + "\u0778\u0005\u031a\u018e\u0002\u0771\u0772\u0007\u0145\u0002\u0002\u0772", + "\u0773\u0007\u009c\u0002\u0002\u0773\u0774\u0007&\u0002\u0002\u0774", + "\u0775\u0007\u015d\u0002\u0002\u0775\u0778\u0005\u031a\u018e\u0002\u0776", + "\u0778\u0005:\u001e\u0002\u0777\u076f\u0003\u0002\u0002\u0002\u0777", + "\u0771\u0003\u0002\u0002\u0002\u0777\u0776\u0003\u0002\u0002\u0002\u0778", + "7\u0003\u0002\u0002\u0002\u0779\u077a\u0005<\u001f\u0002\u077a\u077b", + "\t\b\u0002\u0002\u077b\u077c\u0005> \u0002\u077c9\u0003\u0002\u0002", + "\u0002\u077d\u0797\u00058\u001d\u0002\u077e\u077f\u0005<\u001f\u0002", + "\u077f\u0780\u0007B\u0002\u0002\u0780\u0781\u0007\u01ab\u0002\u0002", + "\u0781\u0797\u0003\u0002\u0002\u0002\u0782\u0783\u0007\u019b\u0002\u0002", + "\u0783\u0784\u0007\u017b\u0002\u0002\u0784\u0797\u0005F$\u0002\u0785", + "\u0786\u0007\u009a\u0002\u0002\u0786\u0797\u0005\u0544\u02a3\u0002\u0787", + "\u0788\u0007\u013c\u0002\u0002\u0788\u0797\u0005\u0544\u02a3\u0002\u0789", + "\u078a\u0007\u0104\u0002\u0002\u078a\u0797\u0005H%\u0002\u078b\u078c", + "\u0007\u0137\u0002\u0002\u078c\u0797\u0005J&\u0002\u078d\u078e\u0007", + "\u0145\u0002\u0002\u078e\u078f\u0007l\u0002\u0002\u078f\u0797\u0005", + "J&\u0002\u0790\u0791\u0007\u0178\u0002\u0002\u0791\u0792\u0007\u0110", + "\u0002\u0002\u0792\u0797\u0005\u04c2\u0262\u0002\u0793\u0794\u0007\u015d", + "\u0002\u0002\u0794\u0795\u0007\u014a\u0002\u0002\u0795\u0797\u0005\u0544", + "\u02a3\u0002\u0796\u077d\u0003\u0002\u0002\u0002\u0796\u077e\u0003\u0002", + "\u0002\u0002\u0796\u0782\u0003\u0002\u0002\u0002\u0796\u0785\u0003\u0002", + "\u0002\u0002\u0796\u0787\u0003\u0002\u0002\u0002\u0796\u0789\u0003\u0002", + "\u0002\u0002\u0796\u078b\u0003\u0002\u0002\u0002\u0796\u078d\u0003\u0002", + "\u0002\u0002\u0796\u0790\u0003\u0002\u0002\u0002\u0796\u0793\u0003\u0002", + "\u0002\u0002\u0797;\u0003\u0002\u0002\u0002\u0798\u079d\u0005\u0552", + "\u02aa\u0002\u0799\u079a\u0007\r\u0002\u0002\u079a\u079c\u0005\u0552", + "\u02aa\u0002\u079b\u0799\u0003\u0002\u0002\u0002\u079c\u079f\u0003\u0002", + "\u0002\u0002\u079d\u079b\u0003\u0002\u0002\u0002\u079d\u079e\u0003\u0002", + "\u0002\u0002\u079e=\u0003\u0002\u0002\u0002\u079f\u079d\u0003\u0002", + "\u0002\u0002\u07a0\u07a5\u0005@!\u0002\u07a1\u07a2\u0007\b\u0002\u0002", + "\u07a2\u07a4\u0005@!\u0002\u07a3\u07a1\u0003\u0002\u0002\u0002\u07a4", + "\u07a7\u0003\u0002\u0002\u0002\u07a5\u07a3\u0003\u0002\u0002\u0002\u07a5", + "\u07a6\u0003\u0002\u0002\u0002\u07a6?\u0003\u0002\u0002\u0002\u07a7", + "\u07a5\u0003\u0002\u0002\u0002\u07a8\u07ab\u0005D#\u0002\u07a9\u07ab", + "\u0005\u0126\u0094\u0002\u07aa\u07a8\u0003\u0002\u0002\u0002\u07aa\u07a9", + "\u0003\u0002\u0002\u0002\u07abA\u0003\u0002\u0002\u0002\u07ac\u07ad", + "\u0007\u0125\u0002\u0002\u07ad\u07b2\t\t\u0002\u0002\u07ae\u07af\u0007", + "\u012f\u0002\u0002\u07af\u07b2\u0007\u0125\u0002\u0002\u07b0\u07b2\u0007", + "\u0143\u0002\u0002\u07b1\u07ac\u0003\u0002\u0002\u0002\u07b1\u07ae\u0003", + "\u0002\u0002\u0002\u07b1\u07b0\u0003\u0002\u0002\u0002\u07b2C\u0003", + "\u0002\u0002\u0002\u07b3\u07b8\u0007b\u0002\u0002\u07b4\u07b8\u0007", + ">\u0002\u0002\u07b5\u07b8\u0007R\u0002\u0002\u07b6\u07b8\u0005J&\u0002", + "\u07b7\u07b3\u0003\u0002\u0002\u0002\u07b7\u07b4\u0003\u0002\u0002\u0002", + "\u07b7\u07b5\u0003\u0002\u0002\u0002\u07b7\u07b6\u0003\u0002\u0002\u0002", + "\u07b8E\u0003\u0002\u0002\u0002\u07b9\u07c9\u0005\u0544\u02a3\u0002", + "\u07ba\u07c9\u0005\u055a\u02ae\u0002\u07bb\u07bc\u0005\u0478\u023d\u0002", + "\u07bc\u07bd\u0005\u0544\u02a3\u0002\u07bd\u07be\u0005\u047c\u023f\u0002", + "\u07be\u07c9\u0003\u0002\u0002\u0002\u07bf\u07c0\u0005\u0478\u023d\u0002", + "\u07c0\u07c1\u0007\u0004\u0002\u0002\u07c1\u07c2\u0005\u0542\u02a2\u0002", + "\u07c2\u07c3\u0007\u0005\u0002\u0002\u07c3\u07c4\u0005\u0544\u02a3\u0002", + "\u07c4\u07c9\u0003\u0002\u0002\u0002\u07c5\u07c9\u0005\u0126\u0094\u0002", + "\u07c6\u07c9\u00077\u0002\u0002\u07c7\u07c9\u0007\u00f7\u0002\u0002", + "\u07c8\u07b9\u0003\u0002\u0002\u0002\u07c8\u07ba\u0003\u0002\u0002\u0002", + "\u07c8\u07bb\u0003\u0002\u0002\u0002\u07c8\u07bf\u0003\u0002\u0002\u0002", + "\u07c8\u07c5\u0003\u0002\u0002\u0002\u07c8\u07c6\u0003\u0002\u0002\u0002", + "\u07c8\u07c7\u0003\u0002\u0002\u0002\u07c9G\u0003\u0002\u0002\u0002", + "\u07ca\u07ce\u0005\u0544\u02a3\u0002\u07cb\u07ce\u00077\u0002\u0002", + "\u07cc\u07ce\u0003\u0002\u0002\u0002\u07cd\u07ca\u0003\u0002\u0002\u0002", + "\u07cd\u07cb\u0003\u0002\u0002\u0002\u07cd\u07cc\u0003\u0002\u0002\u0002", + "\u07ceI\u0003\u0002\u0002\u0002\u07cf\u07d2\u0005\u0556\u02ac\u0002", + "\u07d0\u07d2\u0005\u0544\u02a3\u0002\u07d1\u07cf\u0003\u0002\u0002\u0002", + "\u07d1\u07d0\u0003\u0002\u0002\u0002\u07d2K\u0003\u0002\u0002\u0002", + "\u07d3\u07d4\u0007\u0132\u0002\u0002\u07d4\u07d5\u0005N(\u0002\u07d5", + "M\u0003\u0002\u0002\u0002\u07d6\u07df\u0005P)\u0002\u07d7\u07d8\u0007", + "\u019b\u0002\u0002\u07d8\u07df\u0007\u017b\u0002\u0002\u07d9\u07da\u0007", + "\u015d\u0002\u0002\u07da\u07db\u0007\u00ed\u0002\u0002\u07db\u07df\u0007", + "\u00f4\u0002\u0002\u07dc\u07dd\u0007\u0145\u0002\u0002\u07dd\u07df\u0007", + "l\u0002\u0002\u07de\u07d6\u0003\u0002\u0002\u0002\u07de\u07d7\u0003", + "\u0002\u0002\u0002\u07de\u07d9\u0003\u0002\u0002\u0002\u07de\u07dc\u0003", + "\u0002\u0002\u0002\u07dfO\u0003\u0002\u0002\u0002\u07e0\u07e3\u0005", + "<\u001f\u0002\u07e1\u07e3\u0007 \u0002\u0002\u07e2\u07e0\u0003\u0002", + "\u0002\u0002\u07e2\u07e1\u0003\u0002\u0002\u0002\u07e3Q\u0003\u0002", + "\u0002\u0002\u07e4\u07e5\u0007\u0146\u0002\u0002\u07e5\u07e8\u00056", + "\u001c\u0002\u07e6\u07e8\u0005L\'\u0002\u07e7\u07e4\u0003\u0002\u0002", + "\u0002\u07e7\u07e6\u0003\u0002\u0002\u0002\u07e8S\u0003\u0002\u0002", + "\u0002\u07e9\u07ea\u0007\u0146\u0002\u0002\u07ea\u07ed\u0005:\u001e", + "\u0002\u07eb\u07ed\u0005L\'\u0002\u07ec\u07e9\u0003\u0002\u0002\u0002", + "\u07ec\u07eb\u0003\u0002\u0002\u0002\u07edU\u0003\u0002\u0002\u0002", + "\u07ee\u07f8\u0007\u0148\u0002\u0002\u07ef\u07f9\u0005<\u001f\u0002", + "\u07f0\u07f1\u0007\u019b\u0002\u0002\u07f1\u07f9\u0007\u017b\u0002\u0002", + "\u07f2\u07f3\u0007\u015d\u0002\u0002\u07f3\u07f4\u0007\u00ed\u0002\u0002", + "\u07f4\u07f9\u0007\u00f4\u0002\u0002\u07f5\u07f6\u0007\u0145\u0002\u0002", + "\u07f6\u07f9\u0007l\u0002\u0002\u07f7\u07f9\u0007 \u0002\u0002\u07f8", + "\u07ef\u0003\u0002\u0002\u0002\u07f8\u07f0\u0003\u0002\u0002\u0002\u07f8", + "\u07f2\u0003\u0002\u0002\u0002\u07f8\u07f5\u0003\u0002\u0002\u0002\u07f8", + "\u07f7\u0003\u0002\u0002\u0002\u07f9W\u0003\u0002\u0002\u0002\u07fa", + "\u07fb\u0007\u0146\u0002\u0002\u07fb\u07fc\u0007\u00a7\u0002\u0002\u07fc", + "\u07fd\u0005Z.\u0002\u07fd\u07fe\u0005\\/\u0002\u07feY\u0003\u0002\u0002", + "\u0002\u07ff\u0802\u0007 \u0002\u0002\u0800\u0802\u0005\u052c\u0297", + "\u0002\u0801\u07ff\u0003\u0002\u0002\u0002\u0801\u0800\u0003\u0002\u0002", + "\u0002\u0802[\u0003\u0002\u0002\u0002\u0803\u0804\t\n\u0002\u0002\u0804", + "]\u0003\u0002\u0002\u0002\u0805\u0806\u0007\u009d\u0002\u0002\u0806", + "_\u0003\u0002\u0002\u0002\u0807\u0808\u0007\u00bd\u0002\u0002\u0808", + "\u0809\t\u000b\u0002\u0002\u0809a\u0003\u0002\u0002\u0002\u080a\u080b", + "\u0007\u008c\u0002\u0002\u080b\u080e\u0007^\u0002\u0002\u080c\u080d", + "\u0007\u00de\u0002\u0002\u080d\u080f\u0007\u0185\u0002\u0002\u080e\u080c", + "\u0003\u0002\u0002\u0002\u080e\u080f\u0003\u0002\u0002\u0002\u080f\u0810", + "\u0003\u0002\u0002\u0002\u0810\u0813\u0005\u042a\u0216\u0002\u0811\u0814", + "\u0005d3\u0002\u0812\u0814\u0005f4\u0002\u0813\u0811\u0003\u0002\u0002", + "\u0002\u0813\u0812\u0003\u0002\u0002\u0002\u0814\u0878\u0003\u0002\u0002", + "\u0002\u0815\u0816\u0007\u008c\u0002\u0002\u0816\u0817\u0007^\u0002", + "\u0002\u0817\u0818\u0007 \u0002\u0002\u0818\u0819\u0007F\u0002\u0002", + "\u0819\u081a\u0007\u0158\u0002\u0002\u081a\u081e\u0005\u0532\u029a\u0002", + "\u081b\u081c\u0007\u0112\u0002\u0002\u081c\u081d\u0007\u0095\u0002\u0002", + "\u081d\u081f\u0005\u0550\u02a9\u0002\u081e\u081b\u0003\u0002\u0002\u0002", + "\u081e\u081f\u0003\u0002\u0002\u0002\u081f\u0820\u0003\u0002\u0002\u0002", + "\u0820\u0821\u0007\u0146\u0002\u0002\u0821\u0822\u0007\u0158\u0002\u0002", + "\u0822\u0823\u0005\u0532\u029a\u0002\u0823\u0824\u0005\u03a4\u01d3\u0002", + "\u0824\u0878\u0003\u0002\u0002\u0002\u0825\u0826\u0007\u008c\u0002\u0002", + "\u0826\u0829\u0007\u00e4\u0002\u0002\u0827\u0828\u0007\u00de\u0002\u0002", + "\u0828\u082a\u0007\u0185\u0002\u0002\u0829\u0827\u0003\u0002\u0002\u0002", + "\u0829\u082a\u0003\u0002\u0002\u0002\u082a\u082b\u0003\u0002\u0002\u0002", + "\u082b\u082e\u0005\u052e\u0298\u0002\u082c\u082f\u0005d3\u0002\u082d", + "\u082f\u0005h5\u0002\u082e\u082c\u0003\u0002\u0002\u0002\u082e\u082d", + "\u0003\u0002\u0002\u0002\u082f\u0878\u0003\u0002\u0002\u0002\u0830\u0831", + "\u0007\u008c\u0002\u0002\u0831\u0832\u0007\u00e4\u0002\u0002\u0832\u0833", + "\u0007 \u0002\u0002\u0833\u0834\u0007F\u0002\u0002\u0834\u0835\u0007", + "\u0158\u0002\u0002\u0835\u0839\u0005\u0532\u029a\u0002\u0836\u0837\u0007", + "\u0112\u0002\u0002\u0837\u0838\u0007\u0095\u0002\u0002\u0838\u083a\u0005", + "\u0550\u02a9\u0002\u0839\u0836\u0003\u0002\u0002\u0002\u0839\u083a\u0003", + "\u0002\u0002\u0002\u083a\u083b\u0003\u0002\u0002\u0002\u083b\u083c\u0007", + "\u0146\u0002\u0002\u083c\u083d\u0007\u0158\u0002\u0002\u083d\u083e\u0005", + "\u0532\u029a\u0002\u083e\u083f\u0005\u03a4\u01d3\u0002\u083f\u0878\u0003", + "\u0002\u0002\u0002\u0840\u0841\u0007\u008c\u0002\u0002\u0841\u0844\u0007", + "\u0141\u0002\u0002\u0842\u0843\u0007\u00de\u0002\u0002\u0843\u0845\u0007", + "\u0185\u0002\u0002\u0844\u0842\u0003\u0002\u0002\u0002\u0844\u0845\u0003", + "\u0002\u0002\u0002\u0845\u0846\u0003\u0002\u0002\u0002\u0846\u0847\u0005", + "\u052e\u0298\u0002\u0847\u0848\u0005d3\u0002\u0848\u0878\u0003\u0002", + "\u0002\u0002\u0849\u084a\u0007\u008c\u0002\u0002\u084a\u084d\u0007\u0171", + "\u0002\u0002\u084b\u084c\u0007\u00de\u0002\u0002\u084c\u084e\u0007\u0185", + "\u0002\u0002\u084d\u084b\u0003\u0002\u0002\u0002\u084d\u084e\u0003\u0002", + "\u0002\u0002\u084e\u084f\u0003\u0002\u0002\u0002\u084f\u0850\u0005\u052e", + "\u0298\u0002\u0850\u0851\u0005d3\u0002\u0851\u0878\u0003\u0002\u0002", + "\u0002\u0852\u0853\u0007\u008c\u0002\u0002\u0853\u0854\u0007\u00fc\u0002", + "\u0002\u0854\u0857\u0007\u0171\u0002\u0002\u0855\u0856\u0007\u00de\u0002", + "\u0002\u0856\u0858\u0007\u0185\u0002\u0002\u0857\u0855\u0003\u0002\u0002", + "\u0002\u0857\u0858\u0003\u0002\u0002\u0002\u0858\u0859\u0003\u0002\u0002", + "\u0002\u0859\u085a\u0005\u052e\u0298\u0002\u085a\u085b\u0005d3\u0002", + "\u085b\u0878\u0003\u0002\u0002\u0002\u085c\u085d\u0007\u008c\u0002\u0002", + "\u085d\u085e\u0007\u00fc\u0002\u0002\u085e\u085f\u0007\u0171\u0002\u0002", + "\u085f\u0860\u0007 \u0002\u0002\u0860\u0861\u0007F\u0002\u0002\u0861", + "\u0862\u0007\u0158\u0002\u0002\u0862\u0866\u0005\u0532\u029a\u0002\u0863", + "\u0864\u0007\u0112\u0002\u0002\u0864\u0865\u0007\u0095\u0002\u0002\u0865", + "\u0867\u0005\u0550\u02a9\u0002\u0866\u0863\u0003\u0002\u0002\u0002\u0866", + "\u0867\u0003\u0002\u0002\u0002\u0867\u0868\u0003\u0002\u0002\u0002\u0868", + "\u0869\u0007\u0146\u0002\u0002\u0869\u086a\u0007\u0158\u0002\u0002\u086a", + "\u086b\u0005\u0532\u029a\u0002\u086b\u086c\u0005\u03a4\u01d3\u0002\u086c", + "\u0878\u0003\u0002\u0002\u0002\u086d\u086e\u0007\u008c\u0002\u0002\u086e", + "\u086f\u0007A\u0002\u0002\u086f\u0872\u0007^\u0002\u0002\u0870\u0871", + "\u0007\u00de\u0002\u0002\u0871\u0873\u0007\u0185\u0002\u0002\u0872\u0870", + "\u0003\u0002\u0002\u0002\u0872\u0873\u0003\u0002\u0002\u0002\u0873\u0874", + "\u0003\u0002\u0002\u0002\u0874\u0875\u0005\u042a\u0216\u0002\u0875\u0876", + "\u0005d3\u0002\u0876\u0878\u0003\u0002\u0002\u0002\u0877\u080a\u0003", + "\u0002\u0002\u0002\u0877\u0815\u0003\u0002\u0002\u0002\u0877\u0825\u0003", + "\u0002\u0002\u0002\u0877\u0830\u0003\u0002\u0002\u0002\u0877\u0840\u0003", + "\u0002\u0002\u0002\u0877\u0849\u0003\u0002\u0002\u0002\u0877\u0852\u0003", + "\u0002\u0002\u0002\u0877\u085c\u0003\u0002\u0002\u0002\u0877\u086d\u0003", + "\u0002\u0002\u0002\u0878c\u0003\u0002\u0002\u0002\u0879\u087e\u0005", + "j6\u0002\u087a\u087b\u0007\b\u0002\u0002\u087b\u087d\u0005j6\u0002\u087c", + "\u087a\u0003\u0002\u0002\u0002\u087d\u0880\u0003\u0002\u0002\u0002\u087e", + "\u087c\u0003\u0002\u0002\u0002\u087e\u087f\u0003\u0002\u0002\u0002\u087f", + "e\u0003\u0002\u0002\u0002\u0880\u087e\u0003\u0002\u0002\u0002\u0881", + "\u0882\u0007\u01ac\u0002\u0002\u0882\u0883\u0007\u0116\u0002\u0002\u0883", + "\u0884\u0005\u052e\u0298\u0002\u0884\u0885\u0005\u0082B\u0002\u0885", + "\u088a\u0003\u0002\u0002\u0002\u0886\u0887\u0007\u01ad\u0002\u0002\u0887", + "\u0888\u0007\u0116\u0002\u0002\u0888\u088a\u0005\u052e\u0298\u0002\u0889", + "\u0881\u0003\u0002\u0002\u0002\u0889\u0886\u0003\u0002\u0002\u0002\u088a", + "g\u0003\u0002\u0002\u0002\u088b\u088c\u0007\u01ac\u0002\u0002\u088c", + "\u088d\u0007\u0116\u0002\u0002\u088d\u088e\u0005\u052e\u0298\u0002\u088e", + "i\u0003\u0002\u0002\u0002\u088f\u0890\u0007\u0087\u0002\u0002\u0890", + "\u098c\u0005\u00be`\u0002\u0891\u0892\u0007\u0087\u0002\u0002\u0892", + "\u0893\u0007\u00de\u0002\u0002\u0893\u0894\u0007O\u0002\u0002\u0894", + "\u0895\u0007\u0185\u0002\u0002\u0895\u098c\u0005\u00be`\u0002\u0896", + "\u0897\u0007\u0087\u0002\u0002\u0897\u0898\u0007.\u0002\u0002\u0898", + "\u098c\u0005\u00be`\u0002\u0899\u089a\u0007\u0087\u0002\u0002\u089a", + "\u089b\u0007.\u0002\u0002\u089b\u089c\u0007\u00de\u0002\u0002\u089c", + "\u089d\u0007O\u0002\u0002\u089d\u089e\u0007\u0185\u0002\u0002\u089e", + "\u098c\u0005\u00be`\u0002\u089f\u08a0\u0007\u008c\u0002\u0002\u08a0", + "\u08a1\u0005\u02d6\u016c\u0002\u08a1\u08a2\u0005\u0552\u02aa\u0002\u08a2", + "\u08a3\u0005l7\u0002\u08a3\u098c\u0003\u0002\u0002\u0002\u08a4\u08a5", + "\u0007\u008c\u0002\u0002\u08a5\u08a6\u0005\u02d6\u016c\u0002\u08a6\u08a7", + "\u0005\u0552\u02aa\u0002\u08a7\u08a8\u0007\u00c1\u0002\u0002\u08a8\u08a9", + "\u0007O\u0002\u0002\u08a9\u08aa\u0007P\u0002\u0002\u08aa\u098c\u0003", + "\u0002\u0002\u0002\u08ab\u08ac\u0007\u008c\u0002\u0002\u08ac\u08ad\u0005", + "\u02d6\u016c\u0002\u08ad\u08ae\u0005\u0552\u02aa\u0002\u08ae\u08af\u0007", + "\u0146\u0002\u0002\u08af\u08b0\u0007O\u0002\u0002\u08b0\u08b1\u0007", + "P\u0002\u0002\u08b1\u098c\u0003\u0002\u0002\u0002\u08b2\u08b3\u0007", + "\u008c\u0002\u0002\u08b3\u08b4\u0005\u02d6\u016c\u0002\u08b4\u08b5\u0005", + "\u0552\u02aa\u0002\u08b5\u08b6\u0007\u00c1\u0002\u0002\u08b6\u08b7\u0007", + "\u01ae\u0002\u0002\u08b7\u098c\u0003\u0002\u0002\u0002\u08b8\u08b9\u0007", + "\u008c\u0002\u0002\u08b9\u08ba\u0005\u02d6\u016c\u0002\u08ba\u08bb\u0005", + "\u0552\u02aa\u0002\u08bb\u08bc\u0007\u00c1\u0002\u0002\u08bc\u08bd\u0007", + "\u01ae\u0002\u0002\u08bd\u08be\u0007\u00de\u0002\u0002\u08be\u08bf\u0007", + "\u0185\u0002\u0002\u08bf\u098c\u0003\u0002\u0002\u0002\u08c0\u08c1\u0007", + "\u008c\u0002\u0002\u08c1\u08c2\u0005\u02d6\u016c\u0002\u08c2\u08c3\u0005", + "\u0552\u02aa\u0002\u08c3\u08c4\u0007\u0146\u0002\u0002\u08c4\u08c5\u0007", + "\u014f\u0002\u0002\u08c5\u08c6\u0005\u054a\u02a6\u0002\u08c6\u098c\u0003", + "\u0002\u0002\u0002\u08c7\u08c8\u0007\u008c\u0002\u0002\u08c8\u08c9\u0005", + "\u02d6\u016c\u0002\u08c9\u08ca\u0005\u0542\u02a2\u0002\u08ca\u08cb\u0007", + "\u0146\u0002\u0002\u08cb\u08cc\u0007\u014f\u0002\u0002\u08cc\u08cd\u0005", + "\u054a\u02a6\u0002\u08cd\u098c\u0003\u0002\u0002\u0002\u08ce\u08cf\u0007", + "\u008c\u0002\u0002\u08cf\u08d0\u0005\u02d6\u016c\u0002\u08d0\u08d1\u0005", + "\u0552\u02aa\u0002\u08d1\u08d2\u0007\u0146\u0002\u0002\u08d2\u08d3\u0005", + "v<\u0002\u08d3\u098c\u0003\u0002\u0002\u0002\u08d4\u08d5\u0007\u008c", + "\u0002\u0002\u08d5\u08d6\u0005\u02d6\u016c\u0002\u08d6\u08d7\u0005\u0552", + "\u02aa\u0002\u08d7\u08d8\u0007\u0132\u0002\u0002\u08d8\u08d9\u0005v", + "<\u0002\u08d9\u098c\u0003\u0002\u0002\u0002\u08da\u08db\u0007\u008c", + "\u0002\u0002\u08db\u08dc\u0005\u02d6\u016c\u0002\u08dc\u08dd\u0005\u0552", + "\u02aa\u0002\u08dd\u08de\u0007\u0146\u0002\u0002\u08de\u08df\u0007\u0152", + "\u0002\u0002\u08df\u08e0\u0005\u0552\u02aa\u0002\u08e0\u098c\u0003\u0002", + "\u0002\u0002\u08e1\u08e2\u0007\u008c\u0002\u0002\u08e2\u08e3\u0005\u02d6", + "\u016c\u0002\u08e3\u08e4\u0005\u0552\u02aa\u0002\u08e4\u08e5\u0007\u0087", + "\u0002\u0002\u08e5\u08e6\u0007\u01af\u0002\u0002\u08e6\u08e7\u0005\u00c8", + "e\u0002\u08e7\u08e8\u0007&\u0002\u0002\u08e8\u08e9\u0007\u00dd\u0002", + "\u0002\u08e9\u08ea\u0005\u011e\u0090\u0002\u08ea\u098c\u0003\u0002\u0002", + "\u0002\u08eb\u08ec\u0007\u008c\u0002\u0002\u08ec\u08ed\u0005\u02d6\u016c", + "\u0002\u08ed\u08ee\u0005\u0552\u02aa\u0002\u08ee\u08ef\u0005~@\u0002", + "\u08ef\u098c\u0003\u0002\u0002\u0002\u08f0\u08f1\u0007\u008c\u0002\u0002", + "\u08f1\u08f2\u0005\u02d6\u016c\u0002\u08f2\u08f3\u0005\u0552\u02aa\u0002", + "\u08f3\u08f4\u0007\u00c1\u0002\u0002\u08f4\u08f5\u0007\u00dd\u0002\u0002", + "\u08f5\u098c\u0003\u0002\u0002\u0002\u08f6\u08f7\u0007\u008c\u0002\u0002", + "\u08f7\u08f8\u0005\u02d6\u016c\u0002\u08f8\u08f9\u0005\u0552\u02aa\u0002", + "\u08f9\u08fa\u0007\u00c1\u0002\u0002\u08fa\u08fb\u0007\u00dd\u0002\u0002", + "\u08fb\u08fc\u0007\u00de\u0002\u0002\u08fc\u08fd\u0007\u0185\u0002\u0002", + "\u08fd\u098c\u0003\u0002\u0002\u0002\u08fe\u08ff\u0007\u00c1\u0002\u0002", + "\u08ff\u0900\u0005\u02d6\u016c\u0002\u0900\u0901\u0007\u00de\u0002\u0002", + "\u0901\u0902\u0007\u0185\u0002\u0002\u0902\u0903\u0005\u0552\u02aa\u0002", + "\u0903\u0904\u0005n8\u0002\u0904\u098c\u0003\u0002\u0002\u0002\u0905", + "\u0906\u0007\u00c1\u0002\u0002\u0906\u0907\u0005\u02d6\u016c\u0002\u0907", + "\u0908\u0005\u0552\u02aa\u0002\u0908\u0909\u0005n8\u0002\u0909\u098c", + "\u0003\u0002\u0002\u0002\u090a\u090b\u0007\u008c\u0002\u0002\u090b\u090c", + "\u0005\u02d6\u016c\u0002\u090c\u090d\u0005\u0552\u02aa\u0002\u090d\u090e", + "\u0005\u02d8\u016d\u0002\u090e\u090f\u0007\u0161\u0002\u0002\u090f\u0910", + "\u0005\u0456\u022c\u0002\u0910\u0911\u0005p9\u0002\u0911\u0912\u0005", + "r:\u0002\u0912\u098c\u0003\u0002\u0002\u0002\u0913\u0914\u0007\u008c", + "\u0002\u0002\u0914\u0915\u0005\u02d6\u016c\u0002\u0915\u0916\u0005\u0552", + "\u02aa\u0002\u0916\u0917\u0005\u015a\u00ae\u0002\u0917\u098c\u0003\u0002", + "\u0002\u0002\u0918\u0919\u0007\u0087\u0002\u0002\u0919\u098c\u0005\u00d2", + "j\u0002\u091a\u091b\u0007\u008c\u0002\u0002\u091b\u091c\u0007/\u0002", + "\u0002\u091c\u091d\u0005\u0532\u029a\u0002\u091d\u091e\u0005\u01ba\u00de", + "\u0002\u091e\u098c\u0003\u0002\u0002\u0002\u091f\u0920\u0007\u016d\u0002", + "\u0002\u0920\u0921\u0007/\u0002\u0002\u0921\u098c\u0005\u0532\u029a", + "\u0002\u0922\u0923\u0007\u00c1\u0002\u0002\u0923\u0924\u0007/\u0002", + "\u0002\u0924\u0925\u0007\u00de\u0002\u0002\u0925\u0926\u0007\u0185\u0002", + "\u0002\u0926\u0927\u0005\u0532\u029a\u0002\u0927\u0928\u0005n8\u0002", + "\u0928\u098c\u0003\u0002\u0002\u0002\u0929\u092a\u0007\u00c1\u0002\u0002", + "\u092a\u092b\u0007/\u0002\u0002\u092b\u092c\u0005\u0532\u029a\u0002", + "\u092c\u092d\u0005n8\u0002\u092d\u098c\u0003\u0002\u0002\u0002\u092e", + "\u092f\u0007\u0146\u0002\u0002\u092f\u0930\u0007\u0174\u0002\u0002\u0930", + "\u098c\u0007\u010e\u0002\u0002\u0931\u0932\u0007\u00a0\u0002\u0002\u0932", + "\u0933\u0007R\u0002\u0002\u0933\u098c\u0005\u0532\u029a\u0002\u0934", + "\u0935\u0007\u0146\u0002\u0002\u0935\u0936\u0007\u0174\u0002\u0002\u0936", + "\u098c\u0007\u00a0\u0002\u0002\u0937\u0938\u0007\u0146\u0002\u0002\u0938", + "\u098c\u0007\u01b0\u0002\u0002\u0939\u093a\u0007\u0146\u0002\u0002\u093a", + "\u098c\u0007\u0168\u0002\u0002\u093b\u093c\u0007\u00c3\u0002\u0002\u093c", + "\u093d\u0007\u015e\u0002\u0002\u093d\u098c\u0005\u0532\u029a\u0002\u093e", + "\u093f\u0007\u00c3\u0002\u0002\u093f\u0940\u0007\u008d\u0002\u0002\u0940", + "\u0941\u0007\u015e\u0002\u0002\u0941\u098c\u0005\u0532\u029a\u0002\u0942", + "\u0943\u0007\u00c3\u0002\u0002\u0943\u0944\u0007\u0131\u0002\u0002\u0944", + "\u0945\u0007\u015e\u0002\u0002\u0945\u098c\u0005\u0532\u029a\u0002\u0946", + "\u0947\u0007\u00c3\u0002\u0002\u0947\u0948\u0007\u015e\u0002\u0002\u0948", + "\u098c\u0007 \u0002\u0002\u0949\u094a\u0007\u00c3\u0002\u0002\u094a", + "\u094b\u0007\u015e\u0002\u0002\u094b\u098c\u0007e\u0002\u0002\u094c", + "\u094d\u0007\u00bc\u0002\u0002\u094d\u094e\u0007\u015e\u0002\u0002\u094e", + "\u098c\u0005\u0532\u029a\u0002\u094f\u0950\u0007\u00bc\u0002\u0002\u0950", + "\u0951\u0007\u015e\u0002\u0002\u0951\u098c\u0007 \u0002\u0002\u0952", + "\u0953\u0007\u00bc\u0002\u0002\u0953\u0954\u0007\u015e\u0002\u0002\u0954", + "\u098c\u0007e\u0002\u0002\u0955\u0956\u0007\u00c3\u0002\u0002\u0956", + "\u0957\u0007\u013a\u0002\u0002\u0957\u098c\u0005\u0532\u029a\u0002\u0958", + "\u0959\u0007\u00c3\u0002\u0002\u0959\u095a\u0007\u008d\u0002\u0002\u095a", + "\u095b\u0007\u013a\u0002\u0002\u095b\u098c\u0005\u0532\u029a\u0002\u095c", + "\u095d\u0007\u00c3\u0002\u0002\u095d\u095e\u0007\u0131\u0002\u0002\u095e", + "\u095f\u0007\u013a\u0002\u0002\u095f\u098c\u0005\u0532\u029a\u0002\u0960", + "\u0961\u0007\u00bc\u0002\u0002\u0961\u0962\u0007\u013a\u0002\u0002\u0962", + "\u098c\u0005\u0532\u029a\u0002\u0963\u0964\u0007\u00e6\u0002\u0002\u0964", + "\u098c\u0005\u052e\u0298\u0002\u0965\u0966\u0007\u0106\u0002\u0002\u0966", + "\u0967\u0007\u00e6\u0002\u0002\u0967\u098c\u0005\u052e\u0298\u0002\u0968", + "\u0969\u0007\u010c\u0002\u0002\u0969\u098c\u0005\u020e\u0108\u0002\u096a", + "\u096b\u0007O\u0002\u0002\u096b\u098c\u0007\u010c\u0002\u0002\u096c", + "\u096d\u0007\u0113\u0002\u0002\u096d\u096e\u0007`\u0002\u0002\u096e", + "\u098c\u0005\u054e\u02a8\u0002\u096f\u0970\u0007\u0146\u0002\u0002\u0970", + "\u0971\u0007\u0158\u0002\u0002\u0971\u098c\u0005\u0532\u029a\u0002\u0972", + "\u0973\u0007\u0146\u0002\u0002\u0973\u098c\u0005v<\u0002\u0974\u0975", + "\u0007\u0132\u0002\u0002\u0975\u098c\u0005v<\u0002\u0976\u0977\u0007", + "\u0131\u0002\u0002\u0977\u0978\u0007\u00dd\u0002\u0002\u0978\u098c\u0005", + "t;\u0002\u0979\u097a\u0007\u00c3\u0002\u0002\u097a\u097b\u0007\u0197", + "\u0002\u0002\u097b\u097c\u0007\u00f4\u0002\u0002\u097c\u098c\u0007\u0140", + "\u0002\u0002\u097d\u097e\u0007\u00bc\u0002\u0002\u097e\u097f\u0007\u0197", + "\u0002\u0002\u097f\u0980\u0007\u00f4\u0002\u0002\u0980\u098c\u0007\u0140", + "\u0002\u0002\u0981\u0982\u0007\u00d3\u0002\u0002\u0982\u0983\u0007\u0197", + "\u0002\u0002\u0983\u0984\u0007\u00f4\u0002\u0002\u0984\u098c\u0007\u0140", + "\u0002\u0002\u0985\u0986\u0007\u0106\u0002\u0002\u0986\u0987\u0007\u00d3", + "\u0002\u0002\u0987\u0988\u0007\u0197\u0002\u0002\u0988\u0989\u0007\u00f4", + "\u0002\u0002\u0989\u098c\u0007\u0140\u0002\u0002\u098a\u098c\u0005\u015a", + "\u00ae\u0002\u098b\u088f\u0003\u0002\u0002\u0002\u098b\u0891\u0003\u0002", + "\u0002\u0002\u098b\u0896\u0003\u0002\u0002\u0002\u098b\u0899\u0003\u0002", + "\u0002\u0002\u098b\u089f\u0003\u0002\u0002\u0002\u098b\u08a4\u0003\u0002", + "\u0002\u0002\u098b\u08ab\u0003\u0002\u0002\u0002\u098b\u08b2\u0003\u0002", + "\u0002\u0002\u098b\u08b8\u0003\u0002\u0002\u0002\u098b\u08c0\u0003\u0002", + "\u0002\u0002\u098b\u08c7\u0003\u0002\u0002\u0002\u098b\u08ce\u0003\u0002", + "\u0002\u0002\u098b\u08d4\u0003\u0002\u0002\u0002\u098b\u08da\u0003\u0002", + "\u0002\u0002\u098b\u08e1\u0003\u0002\u0002\u0002\u098b\u08eb\u0003\u0002", + "\u0002\u0002\u098b\u08f0\u0003\u0002\u0002\u0002\u098b\u08f6\u0003\u0002", + "\u0002\u0002\u098b\u08fe\u0003\u0002\u0002\u0002\u098b\u0905\u0003\u0002", + "\u0002\u0002\u098b\u090a\u0003\u0002\u0002\u0002\u098b\u0913\u0003\u0002", + "\u0002\u0002\u098b\u0918\u0003\u0002\u0002\u0002\u098b\u091a\u0003\u0002", + "\u0002\u0002\u098b\u091f\u0003\u0002\u0002\u0002\u098b\u0922\u0003\u0002", + "\u0002\u0002\u098b\u0929\u0003\u0002\u0002\u0002\u098b\u092e\u0003\u0002", + "\u0002\u0002\u098b\u0931\u0003\u0002\u0002\u0002\u098b\u0934\u0003\u0002", + "\u0002\u0002\u098b\u0937\u0003\u0002\u0002\u0002\u098b\u0939\u0003\u0002", + "\u0002\u0002\u098b\u093b\u0003\u0002\u0002\u0002\u098b\u093e\u0003\u0002", + "\u0002\u0002\u098b\u0942\u0003\u0002\u0002\u0002\u098b\u0946\u0003\u0002", + "\u0002\u0002\u098b\u0949\u0003\u0002\u0002\u0002\u098b\u094c\u0003\u0002", + "\u0002\u0002\u098b\u094f\u0003\u0002\u0002\u0002\u098b\u0952\u0003\u0002", + "\u0002\u0002\u098b\u0955\u0003\u0002\u0002\u0002\u098b\u0958\u0003\u0002", + "\u0002\u0002\u098b\u095c\u0003\u0002\u0002\u0002\u098b\u0960\u0003\u0002", + "\u0002\u0002\u098b\u0963\u0003\u0002\u0002\u0002\u098b\u0965\u0003\u0002", + "\u0002\u0002\u098b\u0968\u0003\u0002\u0002\u0002\u098b\u096a\u0003\u0002", + "\u0002\u0002\u098b\u096c\u0003\u0002\u0002\u0002\u098b\u096f\u0003\u0002", + "\u0002\u0002\u098b\u0972\u0003\u0002\u0002\u0002\u098b\u0974\u0003\u0002", + "\u0002\u0002\u098b\u0976\u0003\u0002\u0002\u0002\u098b\u0979\u0003\u0002", + "\u0002\u0002\u098b\u097d\u0003\u0002\u0002\u0002\u098b\u0981\u0003\u0002", + "\u0002\u0002\u098b\u0985\u0003\u0002\u0002\u0002\u098b\u098a\u0003\u0002", + "\u0002\u0002\u098ck\u0003\u0002\u0002\u0002\u098d\u098e\u0007\u0146", + "\u0002\u0002\u098e\u098f\u00077\u0002\u0002\u098f\u0993\u0005\u0482", + "\u0242\u0002\u0990\u0991\u0007\u00c1\u0002\u0002\u0991\u0993\u00077", + "\u0002\u0002\u0992\u098d\u0003\u0002\u0002\u0002\u0992\u0990\u0003\u0002", + "\u0002\u0002\u0993m\u0003\u0002\u0002\u0002\u0994\u0998\u0007\u0098", + "\u0002\u0002\u0995\u0998\u0007\u0134\u0002\u0002\u0996\u0998\u0003\u0002", + "\u0002\u0002\u0997\u0994\u0003\u0002\u0002\u0002\u0997\u0995\u0003\u0002", + "\u0002\u0002\u0997\u0996\u0003\u0002\u0002\u0002\u0998o\u0003\u0002", + "\u0002\u0002\u0999\u099a\u0007-\u0002\u0002\u099a\u099d\u0005\u020e", + "\u0108\u0002\u099b\u099d\u0003\u0002\u0002\u0002\u099c\u0999\u0003\u0002", + "\u0002\u0002\u099c\u099b\u0003\u0002\u0002\u0002\u099dq\u0003\u0002", + "\u0002\u0002\u099e\u099f\u0007f\u0002\u0002\u099f\u09a2\u0005\u0482", + "\u0242\u0002\u09a0\u09a2\u0003\u0002\u0002\u0002\u09a1\u099e\u0003\u0002", + "\u0002\u0002\u09a1\u09a0\u0003\u0002\u0002\u0002\u09a2s\u0003\u0002", + "\u0002\u0002\u09a3\u09aa\u0007\u0107\u0002\u0002\u09a4\u09aa\u0007s", + "\u0002\u0002\u09a5\u09aa\u00077\u0002\u0002\u09a6\u09a7\u0007f\u0002", + "\u0002\u09a7\u09a8\u0007\u00e4\u0002\u0002\u09a8\u09aa\u0005\u0532\u029a", + "\u0002\u09a9\u09a3\u0003\u0002\u0002\u0002\u09a9\u09a4\u0003\u0002\u0002", + "\u0002\u09a9\u09a5\u0003\u0002\u0002\u0002\u09a9\u09a6\u0003\u0002\u0002", + "\u0002\u09aau\u0003\u0002\u0002\u0002\u09ab\u09ac\u0007\u0004\u0002", + "\u0002\u09ac\u09ad\u0005z>\u0002\u09ad\u09ae\u0007\u0005\u0002\u0002", + "\u09aew\u0003\u0002\u0002\u0002\u09af\u09b0\u0007k\u0002\u0002\u09b0", + "\u09b3\u0005v<\u0002\u09b1\u09b3\u0003\u0002\u0002\u0002\u09b2\u09af", + "\u0003\u0002\u0002\u0002\u09b2\u09b1\u0003\u0002\u0002\u0002\u09b3y", + "\u0003\u0002\u0002\u0002\u09b4\u09b9\u0005|?\u0002\u09b5\u09b6\u0007", + "\b\u0002\u0002\u09b6\u09b8\u0005|?\u0002\u09b7\u09b5\u0003\u0002\u0002", + "\u0002\u09b8\u09bb\u0003\u0002\u0002\u0002\u09b9\u09b7\u0003\u0002\u0002", + "\u0002\u09b9\u09ba\u0003\u0002\u0002\u0002\u09ba{\u0003\u0002\u0002", + "\u0002\u09bb\u09b9\u0003\u0002\u0002\u0002\u09bc\u09c5\u0005\u0558\u02ad", + "\u0002\u09bd\u09be\u0007\f\u0002\u0002\u09be\u09c6\u0005\u01d4\u00eb", + "\u0002\u09bf\u09c0\u0007\r\u0002\u0002\u09c0\u09c3\u0005\u0558\u02ad", + "\u0002\u09c1\u09c2\u0007\f\u0002\u0002\u09c2\u09c4\u0005\u01d4\u00eb", + "\u0002\u09c3\u09c1\u0003\u0002\u0002\u0002\u09c3\u09c4\u0003\u0002\u0002", + "\u0002\u09c4\u09c6\u0003\u0002\u0002\u0002\u09c5\u09bd\u0003\u0002\u0002", + "\u0002\u09c5\u09bf\u0003\u0002\u0002\u0002\u09c5\u09c6\u0003\u0002\u0002", + "\u0002\u09c6}\u0003\u0002\u0002\u0002\u09c7\u09c9\u0005\u0080A\u0002", + "\u09c8\u09c7\u0003\u0002\u0002\u0002\u09c9\u09ca\u0003\u0002\u0002\u0002", + "\u09ca\u09c8\u0003\u0002\u0002\u0002\u09ca\u09cb\u0003\u0002\u0002\u0002", + "\u09cb\u007f\u0003\u0002\u0002\u0002\u09cc\u09d0\u0007\u0133\u0002\u0002", + "\u09cd\u09ce\u0005\u0012\n\u0002\u09ce\u09cf\u0005\u0126\u0094\u0002", + "\u09cf\u09d1\u0003\u0002\u0002\u0002\u09d0\u09cd\u0003\u0002\u0002\u0002", + "\u09d0\u09d1\u0003\u0002\u0002\u0002\u09d1\u09d9\u0003\u0002\u0002\u0002", + "\u09d2\u09d6\u0007\u0146\u0002\u0002\u09d3\u09d7\u0005\u0122\u0092\u0002", + "\u09d4\u09d5\u0007\u01af\u0002\u0002\u09d5\u09d7\u0005\u00c8e\u0002", + "\u09d6\u09d3\u0003\u0002\u0002\u0002\u09d6\u09d4\u0003\u0002\u0002\u0002", + "\u09d7\u09d9\u0003\u0002\u0002\u0002\u09d8\u09cc\u0003\u0002\u0002\u0002", + "\u09d8\u09d2\u0003\u0002\u0002\u0002\u09d9\u0081\u0003\u0002\u0002\u0002", + "\u09da\u09db\u0007@\u0002\u0002\u09db\u09dc\u0007\u019f\u0002\u0002", + "\u09dc\u09dd\u0007k\u0002\u0002\u09dd\u09de\u0007\u0004\u0002\u0002", + "\u09de\u09df\u0005\u0086D\u0002\u09df\u09e0\u0007\u0005\u0002\u0002", + "\u09e0\u09f5\u0003\u0002\u0002\u0002\u09e1\u09e2\u0007@\u0002\u0002", + "\u09e2\u09e3\u0007\u019f\u0002\u0002\u09e3\u09e4\u0007F\u0002\u0002", + "\u09e4\u09e5\u0007\u0004\u0002\u0002\u09e5\u09e6\u0005\u04f6\u027c\u0002", + "\u09e6\u09e7\u0007\u0005\u0002\u0002\u09e7\u09f5\u0003\u0002\u0002\u0002", + "\u09e8\u09e9\u0007@\u0002\u0002\u09e9\u09ea\u0007\u019f\u0002\u0002", + "\u09ea\u09eb\u0007B\u0002\u0002\u09eb\u09ec\u0007\u0004\u0002\u0002", + "\u09ec\u09ed\u0005\u04f6\u027c\u0002\u09ed\u09ee\u0007\u0005\u0002\u0002", + "\u09ee\u09ef\u0007`\u0002\u0002\u09ef\u09f0\u0007\u0004\u0002\u0002", + "\u09f0\u09f1\u0005\u04f6\u027c\u0002\u09f1\u09f2\u0007\u0005\u0002\u0002", + "\u09f2\u09f5\u0003\u0002\u0002\u0002\u09f3\u09f5\u00077\u0002\u0002", + "\u09f4\u09da\u0003\u0002\u0002\u0002\u09f4\u09e1\u0003\u0002\u0002\u0002", + "\u09f4\u09e8\u0003\u0002\u0002\u0002\u09f4\u09f3\u0003\u0002\u0002\u0002", + "\u09f5\u0083\u0003\u0002\u0002\u0002\u09f6\u09f7\u0005\u0556\u02ac\u0002", + "\u09f7\u09f8\u0005\u0542\u02a2\u0002\u09f8\u0085\u0003\u0002\u0002\u0002", + "\u09f9\u09fe\u0005\u0084C\u0002\u09fa\u09fb\u0007\b\u0002\u0002\u09fb", + "\u09fd\u0005\u0084C\u0002\u09fc\u09fa\u0003\u0002\u0002\u0002\u09fd", + "\u0a00\u0003\u0002\u0002\u0002\u09fe\u09fc\u0003\u0002\u0002\u0002\u09fe", + "\u09ff\u0003\u0002\u0002\u0002\u09ff\u0087\u0003\u0002\u0002\u0002\u0a00", + "\u09fe\u0003\u0002\u0002\u0002\u0a01\u0a02\u0007\u008c\u0002\u0002\u0a02", + "\u0a03\u0007\u0161\u0002\u0002\u0a03\u0a04\u0005\u020e\u0108\u0002\u0a04", + "\u0a05\u0005\u008aF\u0002\u0a05\u0089\u0003\u0002\u0002\u0002\u0a06", + "\u0a0b\u0005\u008cG\u0002\u0a07\u0a08\u0007\b\u0002\u0002\u0a08\u0a0a", + "\u0005\u008cG\u0002\u0a09\u0a07\u0003\u0002\u0002\u0002\u0a0a\u0a0d", + "\u0003\u0002\u0002\u0002\u0a0b\u0a09\u0003\u0002\u0002\u0002\u0a0b\u0a0c", + "\u0003\u0002\u0002\u0002\u0a0c\u008b\u0003\u0002\u0002\u0002\u0a0d\u0a0b", + "\u0003\u0002\u0002\u0002\u0a0e\u0a0f\u0007\u0087\u0002\u0002\u0a0f\u0a10", + "\u0007\u0091\u0002\u0002\u0a10\u0a11\u0005\u0446\u0224\u0002\u0a11\u0a12", + "\u0005n8\u0002\u0a12\u0a26\u0003\u0002\u0002\u0002\u0a13\u0a14\u0007", + "\u00c1\u0002\u0002\u0a14\u0a17\u0007\u0091\u0002\u0002\u0a15\u0a16\u0007", + "\u00de\u0002\u0002\u0a16\u0a18\u0007\u0185\u0002\u0002\u0a17\u0a15\u0003", + "\u0002\u0002\u0002\u0a17\u0a18\u0003\u0002\u0002\u0002\u0a18\u0a19\u0003", + "\u0002\u0002\u0002\u0a19\u0a1a\u0005\u0552\u02aa\u0002\u0a1a\u0a1b\u0005", + "n8\u0002\u0a1b\u0a26\u0003\u0002\u0002\u0002\u0a1c\u0a1d\u0007\u008c", + "\u0002\u0002\u0a1d\u0a1e\u0007\u0091\u0002\u0002\u0a1e\u0a1f\u0005\u0552", + "\u02aa\u0002\u0a1f\u0a20\u0005\u02d8\u016d\u0002\u0a20\u0a21\u0007\u0161", + "\u0002\u0002\u0a21\u0a22\u0005\u0456\u022c\u0002\u0a22\u0a23\u0005p", + "9\u0002\u0a23\u0a24\u0005n8\u0002\u0a24\u0a26\u0003\u0002\u0002\u0002", + "\u0a25\u0a0e\u0003\u0002\u0002\u0002\u0a25\u0a13\u0003\u0002\u0002\u0002", + "\u0a25\u0a1c\u0003\u0002\u0002\u0002\u0a26\u008d\u0003\u0002\u0002\u0002", + "\u0a27\u0a2a\u0007\u009f\u0002\u0002\u0a28\u0a2b\u0005\u03b4\u01db\u0002", + "\u0a29\u0a2b\u0007 \u0002\u0002\u0a2a\u0a28\u0003\u0002\u0002\u0002", + "\u0a2a\u0a29\u0003\u0002\u0002\u0002\u0a2b\u008f\u0003\u0002\u0002\u0002", + "\u0a2c\u0a2d\u0007\u00ab\u0002\u0002\u0a2d\u0a2e\u0005\u009eP\u0002", + "\u0a2e\u0a2f\u0005\u052e\u0298\u0002\u0a2f\u0a30\u0005\u00d8m\u0002", + "\u0a30\u0a31\u0005\u0092J\u0002\u0a31\u0a32\u0005\u0094K\u0002\u0a32", + "\u0a33\u0005\u0096L\u0002\u0a33\u0a34\u0005\u00a0Q\u0002\u0a34\u0a35", + "\u0005\u0012\n\u0002\u0a35\u0a36\u0005\u0098M\u0002\u0a36\u0a37\u0005", + "\u043e\u0220\u0002\u0a37\u0a43\u0003\u0002\u0002\u0002\u0a38\u0a39\u0007", + "\u00ab\u0002\u0002\u0a39\u0a3a\u0007\u0004\u0002\u0002\u0a3a\u0a3b\u0005", + "\u0380\u01c1\u0002\u0a3b\u0a3c\u0007\u0005\u0002\u0002\u0a3c\u0a3d\u0007", + "`\u0002\u0002\u0a3d\u0a3e\u0005\u0094K\u0002\u0a3e\u0a3f\u0005\u0096", + "L\u0002\u0a3f\u0a40\u0005\u0012\n\u0002\u0a40\u0a41\u0005\u0098M\u0002", + "\u0a41\u0a43\u0003\u0002\u0002\u0002\u0a42\u0a2c\u0003\u0002\u0002\u0002", + "\u0a42\u0a38\u0003\u0002\u0002\u0002\u0a43\u0091\u0003\u0002\u0002\u0002", + "\u0a44\u0a45\t\f\u0002\u0002\u0a45\u0093\u0003\u0002\u0002\u0002\u0a46", + "\u0a49\u0007\u0122\u0002\u0002\u0a47\u0a49\u0003\u0002\u0002\u0002\u0a48", + "\u0a46\u0003\u0002\u0002\u0002\u0a48\u0a47\u0003\u0002\u0002\u0002\u0a49", + "\u0095\u0003\u0002\u0002\u0002\u0a4a\u0a4e\u0005\u0544\u02a3\u0002\u0a4b", + "\u0a4e\u0007\u0150\u0002\u0002\u0a4c\u0a4e\u0007\u0151\u0002\u0002\u0a4d", + "\u0a4a\u0003\u0002\u0002\u0002\u0a4d\u0a4b\u0003\u0002\u0002\u0002\u0a4d", + "\u0a4c\u0003\u0002\u0002\u0002\u0a4e\u0097\u0003\u0002\u0002\u0002\u0a4f", + "\u0a55\u0005\u009aN\u0002\u0a50\u0a51\u0007\u0004\u0002\u0002\u0a51", + "\u0a52\u0005\u00a4S\u0002\u0a52\u0a53\u0007\u0005\u0002\u0002\u0a53", + "\u0a55\u0003\u0002\u0002\u0002\u0a54\u0a4f\u0003\u0002\u0002\u0002\u0a54", + "\u0a50\u0003\u0002\u0002\u0002\u0a55\u0099\u0003\u0002\u0002\u0002\u0a56", + "\u0a58\u0005\u009cO\u0002\u0a57\u0a56\u0003\u0002\u0002\u0002\u0a58", + "\u0a5b\u0003\u0002\u0002\u0002\u0a59\u0a57\u0003\u0002\u0002\u0002\u0a59", + "\u0a5a\u0003\u0002\u0002\u0002\u0a5a\u009b\u0003\u0002\u0002\u0002\u0a5b", + "\u0a59\u0003\u0002\u0002\u0002\u0a5c\u0a80\u0007m\u0002\u0002\u0a5d", + "\u0a80\u0007r\u0002\u0002\u0a5e\u0a5f\u0007\u00b9\u0002\u0002\u0a5f", + "\u0a60\u0005\u0344\u01a3\u0002\u0a60\u0a61\u0005\u0544\u02a3\u0002\u0a61", + "\u0a80\u0003\u0002\u0002\u0002\u0a62\u0a63\u0007P\u0002\u0002\u0a63", + "\u0a64\u0005\u0344\u01a3\u0002\u0a64\u0a65\u0005\u0544\u02a3\u0002\u0a65", + "\u0a80\u0003\u0002\u0002\u0002\u0a66\u0a80\u0007\u00ad\u0002\u0002\u0a67", + "\u0a80\u0007\u00da\u0002\u0002\u0a68\u0a69\u0007\u0123\u0002\u0002\u0a69", + "\u0a6a\u0005\u0344\u01a3\u0002\u0a6a\u0a6b\u0005\u0544\u02a3\u0002\u0a6b", + "\u0a80\u0003\u0002\u0002\u0002\u0a6c\u0a6d\u0007\u00c7\u0002\u0002\u0a6d", + "\u0a6e\u0005\u0344\u01a3\u0002\u0a6e\u0a6f\u0005\u0544\u02a3\u0002\u0a6f", + "\u0a80\u0003\u0002\u0002\u0002\u0a70\u0a71\u0007\u00d3\u0002\u0002\u0a71", + "\u0a72\u0007\u0123\u0002\u0002\u0a72\u0a80\u0005\u00dan\u0002\u0a73", + "\u0a74\u0007\u00d3\u0002\u0002\u0a74\u0a75\u0007\u0123\u0002\u0002\u0a75", + "\u0a80\u0007\u000b\u0002\u0002\u0a76\u0a77\u0007\u00d3\u0002\u0002\u0a77", + "\u0a78\u0007O\u0002\u0002\u0a78\u0a79\u0007P\u0002\u0002\u0a79\u0a80", + "\u0005\u00dan\u0002\u0a7a\u0a7b\u0007\u00d3\u0002\u0002\u0a7b\u0a7c", + "\u0007P\u0002\u0002\u0a7c\u0a80\u0005\u00dan\u0002\u0a7d\u0a7e\u0007", + "\u00c4\u0002\u0002\u0a7e\u0a80\u0005\u0544\u02a3\u0002\u0a7f\u0a5c\u0003", + "\u0002\u0002\u0002\u0a7f\u0a5d\u0003\u0002\u0002\u0002\u0a7f\u0a5e\u0003", + "\u0002\u0002\u0002\u0a7f\u0a62\u0003\u0002\u0002\u0002\u0a7f\u0a66\u0003", + "\u0002\u0002\u0002\u0a7f\u0a67\u0003\u0002\u0002\u0002\u0a7f\u0a68\u0003", + "\u0002\u0002\u0002\u0a7f\u0a6c\u0003\u0002\u0002\u0002\u0a7f\u0a70\u0003", + "\u0002\u0002\u0002\u0a7f\u0a73\u0003\u0002\u0002\u0002\u0a7f\u0a76\u0003", + "\u0002\u0002\u0002\u0a7f\u0a7a\u0003\u0002\u0002\u0002\u0a7f\u0a7d\u0003", + "\u0002\u0002\u0002\u0a80\u009d\u0003\u0002\u0002\u0002\u0a81\u0a84\u0007", + "m\u0002\u0002\u0a82\u0a84\u0003\u0002\u0002\u0002\u0a83\u0a81\u0003", + "\u0002\u0002\u0002\u0a83\u0a82\u0003\u0002\u0002\u0002\u0a84\u009f\u0003", + "\u0002\u0002\u0002\u0a85\u0a86\u0005\u00a2R\u0002\u0a86\u0a87\u0007", + "\u00ba\u0002\u0002\u0a87\u0a88\u0005\u0544\u02a3\u0002\u0a88\u0a8b\u0003", + "\u0002\u0002\u0002\u0a89\u0a8b\u0003\u0002\u0002\u0002\u0a8a\u0a85\u0003", + "\u0002\u0002\u0002\u0a8a\u0a89\u0003\u0002\u0002\u0002\u0a8b\u00a1\u0003", + "\u0002\u0002\u0002\u0a8c\u0a8f\u0007f\u0002\u0002\u0a8d\u0a8f\u0003", + "\u0002\u0002\u0002\u0a8e\u0a8c\u0003\u0002\u0002\u0002\u0a8e\u0a8d\u0003", + "\u0002\u0002\u0002\u0a8f\u00a3\u0003\u0002\u0002\u0002\u0a90\u0a95\u0005", + "\u00a6T\u0002\u0a91\u0a92\u0007\b\u0002\u0002\u0a92\u0a94\u0005\u00a6", + "T\u0002\u0a93\u0a91\u0003\u0002\u0002\u0002\u0a94\u0a97\u0003\u0002", + "\u0002\u0002\u0a95\u0a93\u0003\u0002\u0002\u0002\u0a95\u0a96\u0003\u0002", + "\u0002\u0002\u0a96\u00a5\u0003\u0002\u0002\u0002\u0a97\u0a95\u0003\u0002", + "\u0002\u0002\u0a98\u0a99\u0005\u0558\u02ad\u0002\u0a99\u0a9a\u0005\u00a8", + "U\u0002\u0a9a\u00a7\u0003\u0002\u0002\u0002\u0a9b\u0aa4\u0005D#\u0002", + "\u0a9c\u0aa4\u0005\u0126\u0094\u0002\u0a9d\u0aa4\u0007\u000b\u0002\u0002", + "\u0a9e\u0a9f\u0007\u0004\u0002\u0002\u0a9f\u0aa0\u0005\u00aaV\u0002", + "\u0aa0\u0aa1\u0007\u0005\u0002\u0002\u0aa1\u0aa4\u0003\u0002\u0002\u0002", + "\u0aa2\u0aa4\u0003\u0002\u0002\u0002\u0aa3\u0a9b\u0003\u0002\u0002\u0002", + "\u0aa3\u0a9c\u0003\u0002\u0002\u0002\u0aa3\u0a9d\u0003\u0002\u0002\u0002", + "\u0aa3\u0a9e\u0003\u0002\u0002\u0002\u0aa3\u0aa2\u0003\u0002\u0002\u0002", + "\u0aa4\u00a9\u0003\u0002\u0002\u0002\u0aa5\u0aaa\u0005\u00acW\u0002", + "\u0aa6\u0aa7\u0007\b\u0002\u0002\u0aa7\u0aa9\u0005\u00acW\u0002\u0aa8", + "\u0aa6\u0003\u0002\u0002\u0002\u0aa9\u0aac\u0003\u0002\u0002\u0002\u0aaa", + "\u0aa8\u0003\u0002\u0002\u0002\u0aaa\u0aab\u0003\u0002\u0002\u0002\u0aab", + "\u00ab\u0003\u0002\u0002\u0002\u0aac\u0aaa\u0003\u0002\u0002\u0002\u0aad", + "\u0aae\u0005D#\u0002\u0aae\u00ad\u0003\u0002\u0002\u0002\u0aaf\u0ab0", + "\u00070\u0002\u0002\u0ab0\u0ab1\u0005\u00b0Y\u0002\u0ab1\u0ab5\u0007", + "^\u0002\u0002\u0ab2\u0ab3\u0007\u00de\u0002\u0002\u0ab3\u0ab4\u0007", + "O\u0002\u0002\u0ab4\u0ab6\u0007\u0185\u0002\u0002\u0ab5\u0ab2\u0003", + "\u0002\u0002\u0002\u0ab5\u0ab6\u0003\u0002\u0002\u0002\u0ab6\u0ab7\u0003", + "\u0002\u0002\u0002\u0ab7\u0ad6\u0005\u052e\u0298\u0002\u0ab8\u0ab9\u0007", + "\u0004\u0002\u0002\u0ab9\u0aba\u0005\u00b2Z\u0002\u0aba\u0abb\u0007", + "\u0005\u0002\u0002\u0abb\u0abc\u0005\u00f0y\u0002\u0abc\u0abd\u0005", + "\u00f2z\u0002\u0abd\u0abe\u0005\u00fa~\u0002\u0abe\u0abf\u0005\u00fc", + "\u007f\u0002\u0abf\u0ac0\u0005\u00fe\u0080\u0002\u0ac0\u0ac1\u0005\u0100", + "\u0081\u0002\u0ac1\u0ad7\u0003\u0002\u0002\u0002\u0ac2\u0ac3\u0007\u010c", + "\u0002\u0002\u0ac3\u0ac4\u0005\u020e\u0108\u0002\u0ac4\u0ac5\u0005\u00b4", + "[\u0002\u0ac5\u0ac6\u0005\u00f2z\u0002\u0ac6\u0ac7\u0005\u00fa~\u0002", + "\u0ac7\u0ac8\u0005\u00fc\u007f\u0002\u0ac8\u0ac9\u0005\u00fe\u0080\u0002", + "\u0ac9\u0aca\u0005\u0100\u0081\u0002\u0aca\u0ad7\u0003\u0002\u0002\u0002", + "\u0acb\u0acc\u0007\u0116\u0002\u0002\u0acc\u0acd\u0007\u010c\u0002\u0002", + "\u0acd\u0ace\u0005\u052e\u0298\u0002\u0ace\u0acf\u0005\u00b4[\u0002", + "\u0acf\u0ad0\u0005\u0082B\u0002\u0ad0\u0ad1\u0005\u00f2z\u0002\u0ad1", + "\u0ad2\u0005\u00fa~\u0002\u0ad2\u0ad3\u0005\u00fc\u007f\u0002\u0ad3", + "\u0ad4\u0005\u00fe\u0080\u0002\u0ad4\u0ad5\u0005\u0100\u0081\u0002\u0ad5", + "\u0ad7\u0003\u0002\u0002\u0002\u0ad6\u0ab8\u0003\u0002\u0002\u0002\u0ad6", + "\u0ac2\u0003\u0002\u0002\u0002\u0ad6\u0acb\u0003\u0002\u0002\u0002\u0ad7", + "\u00af\u0003\u0002\u0002\u0002\u0ad8\u0ae1\u0007\u015b\u0002\u0002\u0ad9", + "\u0ae1\u0007\u0159\u0002\u0002\u0ada\u0adb\u0007\u00f7\u0002\u0002\u0adb", + "\u0ae1\t\r\u0002\u0002\u0adc\u0add\u0007\u00d7\u0002\u0002\u0add\u0ae1", + "\t\r\u0002\u0002\u0ade\u0ae1\u0007\u0168\u0002\u0002\u0adf\u0ae1\u0003", + "\u0002\u0002\u0002\u0ae0\u0ad8\u0003\u0002\u0002\u0002\u0ae0\u0ad9\u0003", + "\u0002\u0002\u0002\u0ae0\u0ada\u0003\u0002\u0002\u0002\u0ae0\u0adc\u0003", + "\u0002\u0002\u0002\u0ae0\u0ade\u0003\u0002\u0002\u0002\u0ae0\u0adf\u0003", + "\u0002\u0002\u0002\u0ae1\u00b1\u0003\u0002\u0002\u0002\u0ae2\u0ae5\u0005", + "\u00b6\\\u0002\u0ae3\u0ae5\u0003\u0002\u0002\u0002\u0ae4\u0ae2\u0003", + "\u0002\u0002\u0002\u0ae4\u0ae3\u0003\u0002\u0002\u0002\u0ae5\u00b3\u0003", + "\u0002\u0002\u0002\u0ae6\u0ae7\u0007\u0004\u0002\u0002\u0ae7\u0ae8\u0005", + "\u00b8]\u0002\u0ae8\u0ae9\u0007\u0005\u0002\u0002\u0ae9\u0aec\u0003", + "\u0002\u0002\u0002\u0aea\u0aec\u0003\u0002\u0002\u0002\u0aeb\u0ae6\u0003", + "\u0002\u0002\u0002\u0aeb\u0aea\u0003\u0002\u0002\u0002\u0aec\u00b5\u0003", + "\u0002\u0002\u0002\u0aed\u0af2\u0005\u00ba^\u0002\u0aee\u0aef\u0007", + "\b\u0002\u0002\u0aef\u0af1\u0005\u00ba^\u0002\u0af0\u0aee\u0003\u0002", + "\u0002\u0002\u0af1\u0af4\u0003\u0002\u0002\u0002\u0af2\u0af0\u0003\u0002", + "\u0002\u0002\u0af2\u0af3\u0003\u0002\u0002\u0002\u0af3\u00b7\u0003\u0002", + "\u0002\u0002\u0af4\u0af2\u0003\u0002\u0002\u0002\u0af5\u0afa\u0005\u00bc", + "_\u0002\u0af6\u0af7\u0007\b\u0002\u0002\u0af7\u0af9\u0005\u00bc_\u0002", + "\u0af8\u0af6\u0003\u0002\u0002\u0002\u0af9\u0afc\u0003\u0002\u0002\u0002", + "\u0afa\u0af8\u0003\u0002\u0002\u0002\u0afa\u0afb\u0003\u0002\u0002\u0002", + "\u0afb\u00b9\u0003\u0002\u0002\u0002\u0afc\u0afa\u0003\u0002\u0002\u0002", + "\u0afd\u0b01\u0005\u00be`\u0002\u0afe\u0b01\u0005\u00ccg\u0002\u0aff", + "\u0b01\u0005\u00d2j\u0002\u0b00\u0afd\u0003\u0002\u0002\u0002\u0b00", + "\u0afe\u0003\u0002\u0002\u0002\u0b00\u0aff\u0003\u0002\u0002\u0002\u0b01", + "\u00bb\u0003\u0002\u0002\u0002\u0b02\u0b05\u0005\u00c0a\u0002\u0b03", + "\u0b05\u0005\u00d2j\u0002\u0b04\u0b02\u0003\u0002\u0002\u0002\u0b04", + "\u0b03\u0003\u0002\u0002\u0002\u0b05\u00bd\u0003\u0002\u0002\u0002\u0b06", + "\u0b07\u0005\u0552\u02aa\u0002\u0b07\u0b08\u0005\u0456\u022c\u0002\u0b08", + "\u0b09\u0005\u0156\u00ac\u0002\u0b09\u0b0a\u0005\u00c2b\u0002\u0b0a", + "\u00bf\u0003\u0002\u0002\u0002\u0b0b\u0b0e\u0005\u0552\u02aa\u0002\u0b0c", + "\u0b0d\u0007k\u0002\u0002\u0b0d\u0b0f\u0007\u0111\u0002\u0002\u0b0e", + "\u0b0c\u0003\u0002\u0002\u0002\u0b0e\u0b0f\u0003\u0002\u0002\u0002\u0b0f", + "\u0b10\u0003\u0002\u0002\u0002\u0b10\u0b11\u0005\u00c2b\u0002\u0b11", + "\u00c1\u0003\u0002\u0002\u0002\u0b12\u0b14\u0005\u00c4c\u0002\u0b13", + "\u0b12\u0003\u0002\u0002\u0002\u0b14\u0b17\u0003\u0002\u0002\u0002\u0b15", + "\u0b13\u0003\u0002\u0002\u0002\u0b15\u0b16\u0003\u0002\u0002\u0002\u0b16", + "\u00c3\u0003\u0002\u0002\u0002\u0b17\u0b15\u0003\u0002\u0002\u0002\u0b18", + "\u0b19\u0007/\u0002\u0002\u0b19\u0b1a\u0005\u0532\u029a\u0002\u0b1a", + "\u0b1b\u0005\u00c6d\u0002\u0b1b\u0b21\u0003\u0002\u0002\u0002\u0b1c", + "\u0b21\u0005\u00c6d\u0002\u0b1d\u0b21\u0005\u00caf\u0002\u0b1e\u0b1f", + "\u0007-\u0002\u0002\u0b1f\u0b21\u0005\u020e\u0108\u0002\u0b20\u0b18", + "\u0003\u0002\u0002\u0002\u0b20\u0b1c\u0003\u0002\u0002\u0002\u0b20\u0b1d", + "\u0003\u0002\u0002\u0002\u0b20\u0b1e\u0003\u0002\u0002\u0002\u0b21\u00c5", + "\u0003\u0002\u0002\u0002\u0b22\u0b23\u0007O\u0002\u0002\u0b23\u0b49", + "\u0007P\u0002\u0002\u0b24\u0b49\u0007P\u0002\u0002\u0b25\u0b26\u0007", + "d\u0002\u0002\u0b26\u0b27\u0005\u029a\u014e\u0002\u0b27\u0b28\u0005", + "\u0102\u0082\u0002\u0b28\u0b49\u0003\u0002\u0002\u0002\u0b29\u0b2a\u0007", + "W\u0002\u0002\u0b2a\u0b2b\u0007\u00ee\u0002\u0002\u0b2b\u0b2c\u0005", + "\u029a\u014e\u0002\u0b2c\u0b2d\u0005\u0102\u0082\u0002\u0b2d\u0b49\u0003", + "\u0002\u0002\u0002\u0b2e\u0b2f\u0007,\u0002\u0002\u0b2f\u0b30\u0007", + "\u0004\u0002\u0002\u0b30\u0b31\u0005\u0482\u0242\u0002\u0b31\u0b32\u0007", + "\u0005\u0002\u0002\u0b32\u0b33\u0005\u00d6l\u0002\u0b33\u0b49\u0003", + "\u0002\u0002\u0002\u0b34\u0b35\u00077\u0002\u0002\u0b35\u0b49\u0005", + "\u04aa\u0256\u0002\u0b36\u0b37\u0007\u01af\u0002\u0002\u0b37\u0b38\u0005", + "\u00c8e\u0002\u0b38\u0b40\u0007&\u0002\u0002\u0b39\u0b3a\u0007\u00dd", + "\u0002\u0002\u0b3a\u0b41\u0005\u011e\u0090\u0002\u0b3b\u0b3c\u0007\u0004", + "\u0002\u0002\u0b3c\u0b3d\u0005\u0482\u0242\u0002\u0b3d\u0b3e\u0007\u0005", + "\u0002\u0002\u0b3e\u0b3f\u0007\u01b1\u0002\u0002\u0b3f\u0b41\u0003\u0002", + "\u0002\u0002\u0b40\u0b39\u0003\u0002\u0002\u0002\u0b40\u0b3b\u0003\u0002", + "\u0002\u0002\u0b41\u0b49\u0003\u0002\u0002\u0002\u0b42\u0b43\u0007X", + "\u0002\u0002\u0b43\u0b44\u0005\u052e\u0298\u0002\u0b44\u0b45\u0005\u00d8", + "m\u0002\u0b45\u0b46\u0005\u00e0q\u0002\u0b46\u0b47\u0005\u00e8u\u0002", + "\u0b47\u0b49\u0003\u0002\u0002\u0002\u0b48\u0b22\u0003\u0002\u0002\u0002", + "\u0b48\u0b24\u0003\u0002\u0002\u0002\u0b48\u0b25\u0003\u0002\u0002\u0002", + "\u0b48\u0b29\u0003\u0002\u0002\u0002\u0b48\u0b2e\u0003\u0002\u0002\u0002", + "\u0b48\u0b34\u0003\u0002\u0002\u0002\u0b48\u0b36\u0003\u0002\u0002\u0002", + "\u0b48\u0b42\u0003\u0002\u0002\u0002\u0b49\u00c7\u0003\u0002\u0002\u0002", + "\u0b4a\u0b4e\u0007\u008d\u0002\u0002\u0b4b\u0b4c\u0007\u0095\u0002\u0002", + "\u0b4c\u0b4e\u00077\u0002\u0002\u0b4d\u0b4a\u0003\u0002\u0002\u0002", + "\u0b4d\u0b4b\u0003\u0002\u0002\u0002\u0b4e\u00c9\u0003\u0002\u0002\u0002", + "\u0b4f\u0b55\u00078\u0002\u0002\u0b50\u0b51\u0007O\u0002\u0002\u0b51", + "\u0b55\u00078\u0002\u0002\u0b52\u0b53\u0007G\u0002\u0002\u0b53\u0b55", + "\t\n\u0002\u0002\u0b54\u0b4f\u0003\u0002\u0002\u0002\u0b54\u0b50\u0003", + "\u0002\u0002\u0002\u0b54\u0b52\u0003\u0002\u0002\u0002\u0b55\u00cb\u0003", + "\u0002\u0002\u0002\u0b56\u0b57\u0007z\u0002\u0002\u0b57\u0b58\u0005", + "\u052e\u0298\u0002\u0b58\u0b59\u0005\u00ceh\u0002\u0b59\u00cd\u0003", + "\u0002\u0002\u0002\u0b5a\u0b5b\t\u000e\u0002\u0002\u0b5b\u0b5d\u0005", + "\u00d0i\u0002\u0b5c\u0b5a\u0003\u0002\u0002\u0002\u0b5d\u0b60\u0003", + "\u0002\u0002\u0002\u0b5e\u0b5c\u0003\u0002\u0002\u0002\u0b5e\u0b5f\u0003", + "\u0002\u0002\u0002\u0b5f\u00cf\u0003\u0002\u0002\u0002\u0b60\u0b5e\u0003", + "\u0002\u0002\u0002\u0b61\u0b62\t\u000f\u0002\u0002\u0b62\u00d1\u0003", + "\u0002\u0002\u0002\u0b63\u0b64\u0007/\u0002\u0002\u0b64\u0b65\u0005", + "\u0532\u029a\u0002\u0b65\u0b66\u0005\u00d4k\u0002\u0b66\u0b69\u0003", + "\u0002\u0002\u0002\u0b67\u0b69\u0005\u00d4k\u0002\u0b68\u0b63\u0003", + "\u0002\u0002\u0002\u0b68\u0b67\u0003\u0002\u0002\u0002\u0b69\u00d3\u0003", + "\u0002\u0002\u0002\u0b6a\u0b6b\u0007,\u0002\u0002\u0b6b\u0b6c\u0007", + "\u0004\u0002\u0002\u0b6c\u0b6d\u0005\u0482\u0242\u0002\u0b6d\u0b6e\u0007", + "\u0005\u0002\u0002\u0b6e\u0b6f\u0005\u01ba\u00de\u0002\u0b6f\u0ba5\u0003", + "\u0002\u0002\u0002\u0b70\u0b7c\u0007d\u0002\u0002\u0b71\u0b72\u0007", + "\u0004\u0002\u0002\u0b72\u0b73\u0005\u00dan\u0002\u0b73\u0b74\u0007", + "\u0005\u0002\u0002\u0b74\u0b75\u0005\u00dep\u0002\u0b75\u0b76\u0005", + "\u029a\u014e\u0002\u0b76\u0b77\u0005\u0102\u0082\u0002\u0b77\u0b78\u0005", + "\u01ba\u00de\u0002\u0b78\u0b7d\u0003\u0002\u0002\u0002\u0b79\u0b7a\u0005", + "\u0104\u0083\u0002\u0b7a\u0b7b\u0005\u01ba\u00de\u0002\u0b7b\u0b7d\u0003", + "\u0002\u0002\u0002\u0b7c\u0b71\u0003\u0002\u0002\u0002\u0b7c\u0b79\u0003", + "\u0002\u0002\u0002\u0b7d\u0ba5\u0003\u0002\u0002\u0002\u0b7e\u0b7f\u0007", + "W\u0002\u0002\u0b7f\u0b8b\u0007\u00ee\u0002\u0002\u0b80\u0b81\u0007", + "\u0004\u0002\u0002\u0b81\u0b82\u0005\u00dan\u0002\u0b82\u0b83\u0007", + "\u0005\u0002\u0002\u0b83\u0b84\u0005\u00dep\u0002\u0b84\u0b85\u0005", + "\u029a\u014e\u0002\u0b85\u0b86\u0005\u0102\u0082\u0002\u0b86\u0b87\u0005", + "\u01ba\u00de\u0002\u0b87\u0b8c\u0003\u0002\u0002\u0002\u0b88\u0b89\u0005", + "\u0104\u0083\u0002\u0b89\u0b8a\u0005\u01ba\u00de\u0002\u0b8a\u0b8c\u0003", + "\u0002\u0002\u0002\u0b8b\u0b80\u0003\u0002\u0002\u0002\u0b8b\u0b88\u0003", + "\u0002\u0002\u0002\u0b8c\u0ba5\u0003\u0002\u0002\u0002\u0b8d\u0b8e\u0007", + "\u00c9\u0002\u0002\u0b8e\u0b8f\u0005\u0256\u012c\u0002\u0b8f\u0b90\u0007", + "\u0004\u0002\u0002\u0b90\u0b91\u0005\u00e2r\u0002\u0b91\u0b92\u0007", + "\u0005\u0002\u0002\u0b92\u0b93\u0005\u00dep\u0002\u0b93\u0b94\u0005", + "\u029a\u014e\u0002\u0b94\u0b95\u0005\u0102\u0082\u0002\u0b95\u0b96\u0005", + "\u00e6t\u0002\u0b96\u0b97\u0005\u01ba\u00de\u0002\u0b97\u0ba5\u0003", + "\u0002\u0002\u0002\u0b98\u0b99\u0007A\u0002\u0002\u0b99\u0b9a\u0007", + "\u00ee\u0002\u0002\u0b9a\u0b9b\u0007\u0004\u0002\u0002\u0b9b\u0b9c\u0005", + "\u00dan\u0002\u0b9c\u0b9d\u0007\u0005\u0002\u0002\u0b9d\u0b9e\u0007", + "X\u0002\u0002\u0b9e\u0b9f\u0005\u052e\u0298\u0002\u0b9f\u0ba0\u0005", + "\u00d8m\u0002\u0ba0\u0ba1\u0005\u00e0q\u0002\u0ba1\u0ba2\u0005\u00e8", + "u\u0002\u0ba2\u0ba3\u0005\u01ba\u00de\u0002\u0ba3\u0ba5\u0003\u0002", + "\u0002\u0002\u0ba4\u0b6a\u0003\u0002\u0002\u0002\u0ba4\u0b70\u0003\u0002", + "\u0002\u0002\u0ba4\u0b7e\u0003\u0002\u0002\u0002\u0ba4\u0b8d\u0003\u0002", + "\u0002\u0002\u0ba4\u0b98\u0003\u0002\u0002\u0002\u0ba5\u00d5\u0003\u0002", + "\u0002\u0002\u0ba6\u0ba7\u0007\u0106\u0002\u0002\u0ba7\u0baa\u0007\u00e6", + "\u0002\u0002\u0ba8\u0baa\u0003\u0002\u0002\u0002\u0ba9\u0ba6\u0003\u0002", + "\u0002\u0002\u0ba9\u0ba8\u0003\u0002\u0002\u0002\u0baa\u00d7\u0003\u0002", + "\u0002\u0002\u0bab\u0bac\u0007\u0004\u0002\u0002\u0bac\u0bad\u0005\u00da", + "n\u0002\u0bad\u0bae\u0007\u0005\u0002\u0002\u0bae\u0bb1\u0003\u0002", + "\u0002\u0002\u0baf\u0bb1\u0003\u0002\u0002\u0002\u0bb0\u0bab\u0003\u0002", + "\u0002\u0002\u0bb0\u0baf\u0003\u0002\u0002\u0002\u0bb1\u00d9\u0003\u0002", + "\u0002\u0002\u0bb2\u0bb7\u0005\u00dco\u0002\u0bb3\u0bb4\u0007\b\u0002", + "\u0002\u0bb4\u0bb6\u0005\u00dco\u0002\u0bb5\u0bb3\u0003\u0002\u0002", + "\u0002\u0bb6\u0bb9\u0003\u0002\u0002\u0002\u0bb7\u0bb5\u0003\u0002\u0002", + "\u0002\u0bb7\u0bb8\u0003\u0002\u0002\u0002\u0bb8\u00db\u0003\u0002\u0002", + "\u0002\u0bb9\u0bb7\u0003\u0002\u0002\u0002\u0bba\u0bbb\u0005\u0552\u02aa", + "\u0002\u0bbb\u00dd\u0003\u0002\u0002\u0002\u0bbc\u0bbd\u0007\u01b2\u0002", + "\u0002\u0bbd\u0bbe\u0007\u0004\u0002\u0002\u0bbe\u0bbf\u0005\u00dan", + "\u0002\u0bbf\u0bc0\u0007\u0005\u0002\u0002\u0bc0\u0bc3\u0003\u0002\u0002", + "\u0002\u0bc1\u0bc3\u0003\u0002\u0002\u0002\u0bc2\u0bbc\u0003\u0002\u0002", + "\u0002\u0bc2\u0bc1\u0003\u0002\u0002\u0002\u0bc3\u00df\u0003\u0002\u0002", + "\u0002\u0bc4\u0bc5\u0007\u00fb\u0002\u0002\u0bc5\u0bc8\t\u0010\u0002", + "\u0002\u0bc6\u0bc8\u0003\u0002\u0002\u0002\u0bc7\u0bc4\u0003\u0002\u0002", + "\u0002\u0bc7\u0bc6\u0003\u0002\u0002\u0002\u0bc8\u00e1\u0003\u0002\u0002", + "\u0002\u0bc9\u0bce\u0005\u00e4s\u0002\u0bca\u0bcb\u0007\b\u0002\u0002", + "\u0bcb\u0bcd\u0005\u00e4s\u0002\u0bcc\u0bca\u0003\u0002\u0002\u0002", + "\u0bcd\u0bd0\u0003\u0002\u0002\u0002\u0bce\u0bcc\u0003\u0002\u0002\u0002", + "\u0bce\u0bcf\u0003\u0002\u0002\u0002\u0bcf\u00e3\u0003\u0002\u0002\u0002", + "\u0bd0\u0bce\u0003\u0002\u0002\u0002\u0bd1\u0bd2\u0005\u025c\u012f\u0002", + "\u0bd2\u0bd9\u0007k\u0002\u0002\u0bd3\u0bda\u0005\u02ae\u0158\u0002", + "\u0bd4\u0bd5\u0007\u010f\u0002\u0002\u0bd5\u0bd6\u0007\u0004\u0002\u0002", + "\u0bd6\u0bd7\u0005\u02ae\u0158\u0002\u0bd7\u0bd8\u0007\u0005\u0002\u0002", + "\u0bd8\u0bda\u0003\u0002\u0002\u0002\u0bd9\u0bd3\u0003\u0002\u0002\u0002", + "\u0bd9\u0bd4\u0003\u0002\u0002\u0002\u0bda\u00e5\u0003\u0002\u0002\u0002", + "\u0bdb\u0bdc\u0007i\u0002\u0002\u0bdc\u0bdd\u0007\u0004\u0002\u0002", + "\u0bdd\u0bde\u0005\u0482\u0242\u0002\u0bde\u0bdf\u0007\u0005\u0002\u0002", + "\u0bdf\u0be2\u0003\u0002\u0002\u0002\u0be0\u0be2\u0003\u0002\u0002\u0002", + "\u0be1\u0bdb\u0003\u0002\u0002\u0002\u0be1\u0be0\u0003\u0002\u0002\u0002", + "\u0be2\u00e7\u0003\u0002\u0002\u0002\u0be3\u0bed\u0005\u00eav\u0002", + "\u0be4\u0bed\u0005\u00ecw\u0002\u0be5\u0be6\u0005\u00eav\u0002\u0be6", + "\u0be7\u0005\u00ecw\u0002\u0be7\u0bed\u0003\u0002\u0002\u0002\u0be8", + "\u0be9\u0005\u00ecw\u0002\u0be9\u0bea\u0005\u00eav\u0002\u0bea\u0bed", + "\u0003\u0002\u0002\u0002\u0beb\u0bed\u0003\u0002\u0002\u0002\u0bec\u0be3", + "\u0003\u0002\u0002\u0002\u0bec\u0be4\u0003\u0002\u0002\u0002\u0bec\u0be5", + "\u0003\u0002\u0002\u0002\u0bec\u0be8\u0003\u0002\u0002\u0002\u0bec\u0beb", + "\u0003\u0002\u0002\u0002\u0bed\u00e9\u0003\u0002\u0002\u0002\u0bee\u0bef", + "\u0007R\u0002\u0002\u0bef\u0bf0\u0007\u016a\u0002\u0002\u0bf0\u0bf1", + "\u0005\u00eex\u0002\u0bf1\u00eb\u0003\u0002\u0002\u0002\u0bf2\u0bf3", + "\u0007R\u0002\u0002\u0bf3\u0bf4\u0007\u00b8\u0002\u0002\u0bf4\u0bf5", + "\u0005\u00eex\u0002\u0bf5\u00ed\u0003\u0002\u0002\u0002\u0bf6\u0bf7", + "\u0007\u0106\u0002\u0002\u0bf7\u0bfd\u0007\u0086\u0002\u0002\u0bf8\u0bfd", + "\u0007\u0134\u0002\u0002\u0bf9\u0bfd\u0007\u0098\u0002\u0002\u0bfa\u0bfb", + "\u0007\u0146\u0002\u0002\u0bfb\u0bfd\t\u0011\u0002\u0002\u0bfc\u0bf6", + "\u0003\u0002\u0002\u0002\u0bfc\u0bf8\u0003\u0002\u0002\u0002\u0bfc\u0bf9", + "\u0003\u0002\u0002\u0002\u0bfc\u0bfa\u0003\u0002\u0002\u0002\u0bfd\u00ef", + "\u0003\u0002\u0002\u0002\u0bfe\u0bff\u0007\u00e7\u0002\u0002\u0bff\u0c00", + "\u0007\u0004\u0002\u0002\u0c00\u0c01\u0005\u052c\u0297\u0002\u0c01\u0c02", + "\u0007\u0005\u0002\u0002\u0c02\u0c05\u0003\u0002\u0002\u0002\u0c03\u0c05", + "\u0003\u0002\u0002\u0002\u0c04\u0bfe\u0003\u0002\u0002\u0002\u0c04\u0c03", + "\u0003\u0002\u0002\u0002\u0c05\u00f1\u0003\u0002\u0002\u0002\u0c06\u0c09", + "\u0005\u00f4{\u0002\u0c07\u0c09\u0003\u0002\u0002\u0002\u0c08\u0c06", + "\u0003\u0002\u0002\u0002\u0c08\u0c07\u0003\u0002\u0002\u0002\u0c09\u00f3", + "\u0003\u0002\u0002\u0002\u0c0a\u0c0b\u0007\u0116\u0002\u0002\u0c0b\u0c0c", + "\u0007\u0095\u0002\u0002\u0c0c\u0c0d\u0005\u0552\u02aa\u0002\u0c0d\u0c0e", + "\u0007\u0004\u0002\u0002\u0c0e\u0c0f\u0005\u00f6|\u0002\u0c0f\u0c10", + "\u0007\u0005\u0002\u0002\u0c10\u00f5\u0003\u0002\u0002\u0002\u0c11\u0c16", + "\u0005\u00f8}\u0002\u0c12\u0c13\u0007\b\u0002\u0002\u0c13\u0c15\u0005", + "\u00f8}\u0002\u0c14\u0c12\u0003\u0002\u0002\u0002\u0c15\u0c18\u0003", + "\u0002\u0002\u0002\u0c16\u0c14\u0003\u0002\u0002\u0002\u0c16\u0c17\u0003", + "\u0002\u0002\u0002\u0c17\u00f7\u0003\u0002\u0002\u0002\u0c18\u0c16\u0003", + "\u0002\u0002\u0002\u0c19\u0c1a\u0005\u0552\u02aa\u0002\u0c1a\u0c1b\u0005", + "\u0262\u0132\u0002\u0c1b\u0c1c\u0005\u0264\u0133\u0002\u0c1c\u0c28\u0003", + "\u0002\u0002\u0002\u0c1d\u0c1e\u0005\u04b4\u025b\u0002\u0c1e\u0c1f\u0005", + "\u0262\u0132\u0002\u0c1f\u0c20\u0005\u0264\u0133\u0002\u0c20\u0c28\u0003", + "\u0002\u0002\u0002\u0c21\u0c22\u0007\u0004\u0002\u0002\u0c22\u0c23\u0005", + "\u0482\u0242\u0002\u0c23\u0c24\u0007\u0005\u0002\u0002\u0c24\u0c25\u0005", + "\u0262\u0132\u0002\u0c25\u0c26\u0005\u0264\u0133\u0002\u0c26\u0c28\u0003", + "\u0002\u0002\u0002\u0c27\u0c19\u0003\u0002\u0002\u0002\u0c27\u0c1d\u0003", + "\u0002\u0002\u0002\u0c27\u0c21\u0003\u0002\u0002\u0002\u0c28\u00f9\u0003", + "\u0002\u0002\u0002\u0c29\u0c2a\u0007f\u0002\u0002\u0c2a\u0c2d\u0005", + "\u0532\u029a\u0002\u0c2b\u0c2d\u0003\u0002\u0002\u0002\u0c2c\u0c29\u0003", + "\u0002\u0002\u0002\u0c2c\u0c2b\u0003\u0002\u0002\u0002\u0c2d\u00fb\u0003", + "\u0002\u0002\u0002\u0c2e\u0c2f\u0007k\u0002\u0002\u0c2f\u0c34\u0005", + "v<\u0002\u0c30\u0c31\u0007\u0174\u0002\u0002\u0c31\u0c34\u0007\u010e", + "\u0002\u0002\u0c32\u0c34\u0003\u0002\u0002\u0002\u0c33\u0c2e\u0003\u0002", + "\u0002\u0002\u0c33\u0c30\u0003\u0002\u0002\u0002\u0c33\u0c32\u0003\u0002", + "\u0002\u0002\u0c34\u00fd\u0003\u0002\u0002\u0002\u0c35\u0c36\u0007R", + "\u0002\u0002\u0c36\u0c3c\u0007\u00a3\u0002\u0002\u0c37\u0c3d\u0007\u00c1", + "\u0002\u0002\u0c38\u0c39\u0007\u00b8\u0002\u0002\u0c39\u0c3d\u0007\u0139", + "\u0002\u0002\u0c3a\u0c3b\u0007\u011d\u0002\u0002\u0c3b\u0c3d\u0007\u0139", + "\u0002\u0002\u0c3c\u0c37\u0003\u0002\u0002\u0002\u0c3c\u0c38\u0003\u0002", + "\u0002\u0002\u0c3c\u0c3a\u0003\u0002\u0002\u0002\u0c3d\u0c40\u0003\u0002", + "\u0002\u0002\u0c3e\u0c40\u0003\u0002\u0002\u0002\u0c3f\u0c35\u0003\u0002", + "\u0002\u0002\u0c3f\u0c3e\u0003\u0002\u0002\u0002\u0c40\u00ff\u0003\u0002", + "\u0002\u0002\u0c41\u0c42\u0007\u0158\u0002\u0002\u0c42\u0c45\u0005\u0532", + "\u029a\u0002\u0c43\u0c45\u0003\u0002\u0002\u0002\u0c44\u0c41\u0003\u0002", + "\u0002\u0002\u0c44\u0c43\u0003\u0002\u0002\u0002\u0c45\u0101\u0003\u0002", + "\u0002\u0002\u0c46\u0c47\u0007f\u0002\u0002\u0c47\u0c48\u0007\u00e4", + "\u0002\u0002\u0c48\u0c49\u0007\u0158\u0002\u0002\u0c49\u0c4c\u0005\u0532", + "\u029a\u0002\u0c4a\u0c4c\u0003\u0002\u0002\u0002\u0c4b\u0c46\u0003\u0002", + "\u0002\u0002\u0c4b\u0c4a\u0003\u0002\u0002\u0002\u0c4c\u0103\u0003\u0002", + "\u0002\u0002\u0c4d\u0c4e\u0007f\u0002\u0002\u0c4e\u0c4f\u0007\u00e4", + "\u0002\u0002\u0c4f\u0c50\u0005\u0532\u029a\u0002\u0c50\u0105\u0003\u0002", + "\u0002\u0002\u0c51\u0c52\u00070\u0002\u0002\u0c52\u0c56\u0007\u014f", + "\u0002\u0002\u0c53\u0c54\u0007\u00de\u0002\u0002\u0c54\u0c55\u0007O", + "\u0002\u0002\u0c55\u0c57\u0007\u0185\u0002\u0002\u0c56\u0c53\u0003\u0002", + "\u0002\u0002\u0c56\u0c57\u0003\u0002\u0002\u0002\u0c57\u0c58\u0003\u0002", + "\u0002\u0002\u0c58\u0c59\u0005\u020e\u0108\u0002\u0c59\u0c5a\u0005\u0368", + "\u01b5\u0002\u0c5a\u0c5b\u0007R\u0002\u0002\u0c5b\u0c5c\u0005\u04f6", + "\u027c\u0002\u0c5c\u0c5d\u0007B\u0002\u0002\u0c5d\u0c5e\u0005\u041c", + "\u020f\u0002\u0c5e\u0107\u0003\u0002\u0002\u0002\u0c5f\u0c60\u0007\u008c", + "\u0002\u0002\u0c60\u0c63\u0007\u014f\u0002\u0002\u0c61\u0c62\u0007\u00de", + "\u0002\u0002\u0c62\u0c64\u0007\u0185\u0002\u0002\u0c63\u0c61\u0003\u0002", + "\u0002\u0002\u0c63\u0c64\u0003\u0002\u0002\u0002\u0c64\u0c65\u0003\u0002", + "\u0002\u0002\u0c65\u0c66\u0005\u020e\u0108\u0002\u0c66\u0c67\u0007\u0146", + "\u0002\u0002\u0c67\u0c68\u0007\u014f\u0002\u0002\u0c68\u0c69\u0005\u054a", + "\u02a6\u0002\u0c69\u0109\u0003\u0002\u0002\u0002\u0c6a\u0c6b\u00070", + "\u0002\u0002\u0c6b\u0c6c\u0005\u00b0Y\u0002\u0c6c\u0c70\u0007^\u0002", + "\u0002\u0c6d\u0c6e\u0007\u00de\u0002\u0002\u0c6e\u0c6f\u0007O\u0002", + "\u0002\u0c6f\u0c71\u0007\u0185\u0002\u0002\u0c70\u0c6d\u0003\u0002\u0002", + "\u0002\u0c70\u0c71\u0003\u0002\u0002\u0002\u0c71\u0c72\u0003\u0002\u0002", + "\u0002\u0c72\u0c73\u0005\u010c\u0087\u0002\u0c73\u0c74\u0007&\u0002", + "\u0002\u0c74\u0c75\u0005\u03ba\u01de\u0002\u0c75\u0c76\u0005\u010e\u0088", + "\u0002\u0c76\u010b\u0003\u0002\u0002\u0002\u0c77\u0c78\u0005\u052e\u0298", + "\u0002\u0c78\u0c79\u0005\u00d8m\u0002\u0c79\u0c7a\u0005\u00fa~\u0002", + "\u0c7a\u0c7b\u0005\u00fc\u007f\u0002\u0c7b\u0c7c\u0005\u00fe\u0080\u0002", + "\u0c7c\u0c7d\u0005\u0100\u0081\u0002\u0c7d\u010d\u0003\u0002\u0002\u0002", + "\u0c7e\u0c82\u0007k\u0002\u0002\u0c7f\u0c83\u0007\u00b0\u0002\u0002", + "\u0c80\u0c81\u0007\u0106\u0002\u0002\u0c81\u0c83\u0007\u00b0\u0002\u0002", + "\u0c82\u0c7f\u0003\u0002\u0002\u0002\u0c82\u0c80\u0003\u0002\u0002\u0002", + "\u0c83\u0c86\u0003\u0002\u0002\u0002\u0c84\u0c86\u0003\u0002\u0002\u0002", + "\u0c85\u0c7e\u0003\u0002\u0002\u0002\u0c85\u0c84\u0003\u0002\u0002\u0002", + "\u0c86\u010f\u0003\u0002\u0002\u0002\u0c87\u0c88\u00070\u0002\u0002", + "\u0c88\u0c89\u0005\u0114\u008b\u0002\u0c89\u0c8a\u0007\u00fc\u0002\u0002", + "\u0c8a\u0c8e\u0007\u0171\u0002\u0002\u0c8b\u0c8c\u0007\u00de\u0002\u0002", + "\u0c8c\u0c8d\u0007O\u0002\u0002\u0c8d\u0c8f\u0007\u0185\u0002\u0002", + "\u0c8e\u0c8b\u0003\u0002\u0002\u0002\u0c8e\u0c8f\u0003\u0002\u0002\u0002", + "\u0c8f\u0c90\u0003\u0002\u0002\u0002\u0c90\u0c91\u0005\u0112\u008a\u0002", + "\u0c91\u0c92\u0007&\u0002\u0002\u0c92\u0c93\u0005\u03ba\u01de\u0002", + "\u0c93\u0c94\u0005\u010e\u0088\u0002\u0c94\u0111\u0003\u0002\u0002\u0002", + "\u0c95\u0c96\u0005\u052e\u0298\u0002\u0c96\u0c97\u0005\u00d8m\u0002", + "\u0c97\u0c98\u0005\u00fa~\u0002\u0c98\u0c99\u0005x=\u0002\u0c99\u0c9a", + "\u0005\u0100\u0081\u0002\u0c9a\u0113\u0003\u0002\u0002\u0002\u0c9b\u0c9e", + "\u0007\u0168\u0002\u0002\u0c9c\u0c9e\u0003\u0002\u0002\u0002\u0c9d\u0c9b", + "\u0003\u0002\u0002\u0002\u0c9d\u0c9c\u0003\u0002\u0002\u0002\u0c9e\u0115", + "\u0003\u0002\u0002\u0002\u0c9f\u0ca0\u0007\u012a\u0002\u0002\u0ca0\u0ca1", + "\u0007\u00fc\u0002\u0002\u0ca1\u0ca2\u0007\u0171\u0002\u0002\u0ca2\u0ca3", + "\u0005\u0252\u012a\u0002\u0ca3\u0ca4\u0005\u052e\u0298\u0002\u0ca4\u0ca5", + "\u0005\u010e\u0088\u0002\u0ca5\u0117\u0003\u0002\u0002\u0002\u0ca6\u0ca7", + "\u00070\u0002\u0002\u0ca7\u0ca8\u0005\u00b0Y\u0002\u0ca8\u0cac\u0007", + "\u0141\u0002\u0002\u0ca9\u0caa\u0007\u00de\u0002\u0002\u0caa\u0cab\u0007", + "O\u0002\u0002\u0cab\u0cad\u0007\u0185\u0002\u0002\u0cac\u0ca9\u0003", + "\u0002\u0002\u0002\u0cac\u0cad\u0003\u0002\u0002\u0002\u0cad\u0cae\u0003", + "\u0002\u0002\u0002\u0cae\u0caf\u0005\u052e\u0298\u0002\u0caf\u0cb0\u0005", + "\u011c\u008f\u0002\u0cb0\u0119\u0003\u0002\u0002\u0002\u0cb1\u0cb2\u0007", + "\u008c\u0002\u0002\u0cb2\u0cb5\u0007\u0141\u0002\u0002\u0cb3\u0cb4\u0007", + "\u00de\u0002\u0002\u0cb4\u0cb6\u0007\u0185\u0002\u0002\u0cb5\u0cb3\u0003", + "\u0002\u0002\u0002\u0cb5\u0cb6\u0003\u0002\u0002\u0002\u0cb6\u0cb7\u0003", + "\u0002\u0002\u0002\u0cb7\u0cb8\u0005\u052e\u0298\u0002\u0cb8\u0cb9\u0005", + "\u0120\u0091\u0002\u0cb9\u011b\u0003\u0002\u0002\u0002\u0cba\u0cbd\u0005", + "\u0120\u0091\u0002\u0cbb\u0cbd\u0003\u0002\u0002\u0002\u0cbc\u0cba\u0003", + "\u0002\u0002\u0002\u0cbc\u0cbb\u0003\u0002\u0002\u0002\u0cbd\u011d\u0003", + "\u0002\u0002\u0002\u0cbe\u0cbf\u0007\u0004\u0002\u0002\u0cbf\u0cc0\u0005", + "\u0120\u0091\u0002\u0cc0\u0cc1\u0007\u0005\u0002\u0002\u0cc1\u0cc4\u0003", + "\u0002\u0002\u0002\u0cc2\u0cc4\u0003\u0002\u0002\u0002\u0cc3\u0cbe\u0003", + "\u0002\u0002\u0002\u0cc3\u0cc2\u0003\u0002\u0002\u0002\u0cc4\u011f\u0003", + "\u0002\u0002\u0002\u0cc5\u0cc7\u0005\u0122\u0092\u0002\u0cc6\u0cc5\u0003", + "\u0002\u0002\u0002\u0cc7\u0cc8\u0003\u0002\u0002\u0002\u0cc8\u0cc6\u0003", + "\u0002\u0002\u0002\u0cc8\u0cc9\u0003\u0002\u0002\u0002\u0cc9\u0121\u0003", + "\u0002\u0002\u0002\u0cca\u0ccb\u0007&\u0002\u0002\u0ccb\u0ce9\u0005", + "\u045a\u022e\u0002\u0ccc\u0ccd\u0007\u0096\u0002\u0002\u0ccd\u0ce9\u0005", + "\u0126\u0094\u0002\u0cce\u0ce9\u0007\u00af\u0002\u0002\u0ccf\u0cd0\u0007", + "\u00e3\u0002\u0002\u0cd0\u0cd1\u0005\u0124\u0093\u0002\u0cd1\u0cd2\u0005", + "\u0126\u0094\u0002\u0cd2\u0ce9\u0003\u0002\u0002\u0002\u0cd3\u0cd4\u0007", + "\u00fd\u0002\u0002\u0cd4\u0ce9\u0005\u0126\u0094\u0002\u0cd5\u0cd6\u0007", + "\u00ff\u0002\u0002\u0cd6\u0ce9\u0005\u0126\u0094\u0002\u0cd7\u0cd8\u0007", + "\u0106\u0002\u0002\u0cd8\u0ce9\t\u0012\u0002\u0002\u0cd9\u0cda\u0007", + "\u0112\u0002\u0002\u0cda\u0cdb\u0007\u0095\u0002\u0002\u0cdb\u0ce9\u0005", + "\u020e\u0108\u0002\u0cdc\u0cdd\u0007\u0141\u0002\u0002\u0cdd\u0cde\u0007", + "\u0103\u0002\u0002\u0cde\u0ce9\u0005\u020e\u0108\u0002\u0cdf\u0ce0\u0007", + "\u014d\u0002\u0002\u0ce0\u0ce1\u0005\u0012\n\u0002\u0ce1\u0ce2\u0005", + "\u0126\u0094\u0002\u0ce2\u0ce9\u0003\u0002\u0002\u0002\u0ce3\u0ce4\u0007", + "\u0133\u0002\u0002\u0ce4\u0ce6\u0005\u0012\n\u0002\u0ce5\u0ce7\u0005", + "\u0126\u0094\u0002\u0ce6\u0ce5\u0003\u0002\u0002\u0002\u0ce6\u0ce7\u0003", + "\u0002\u0002\u0002\u0ce7\u0ce9\u0003\u0002\u0002\u0002\u0ce8\u0cca\u0003", + "\u0002\u0002\u0002\u0ce8\u0ccc\u0003\u0002\u0002\u0002\u0ce8\u0cce\u0003", + "\u0002\u0002\u0002\u0ce8\u0ccf\u0003\u0002\u0002\u0002\u0ce8\u0cd3\u0003", + "\u0002\u0002\u0002\u0ce8\u0cd5\u0003\u0002\u0002\u0002\u0ce8\u0cd7\u0003", + "\u0002\u0002\u0002\u0ce8\u0cd9\u0003\u0002\u0002\u0002\u0ce8\u0cdc\u0003", + "\u0002\u0002\u0002\u0ce8\u0cdf\u0003\u0002\u0002\u0002\u0ce8\u0ce3\u0003", + "\u0002\u0002\u0002\u0ce9\u0123\u0003\u0002\u0002\u0002\u0cea\u0ced\u0007", + "\u0095\u0002\u0002\u0ceb\u0ced\u0003\u0002\u0002\u0002\u0cec\u0cea\u0003", + "\u0002\u0002\u0002\u0cec\u0ceb\u0003\u0002\u0002\u0002\u0ced\u0125\u0003", + "\u0002\u0002\u0002\u0cee\u0cf5\u0005\u0540\u02a1\u0002\u0cef\u0cf0\u0007", + "\u000e\u0002\u0002\u0cf0\u0cf5\u0005\u0540\u02a1\u0002\u0cf1\u0cf2\u0007", + "\u000f\u0002\u0002\u0cf2\u0cf5\u0005\u0540\u02a1\u0002\u0cf3\u0cf5\u0005", + "\u054a\u02a6\u0002\u0cf4\u0cee\u0003\u0002\u0002\u0002\u0cf4\u0cef\u0003", + "\u0002\u0002\u0002\u0cf4\u0cf1\u0003\u0002\u0002\u0002\u0cf4\u0cf3\u0003", + "\u0002\u0002\u0002\u0cf5\u0127\u0003\u0002\u0002\u0002\u0cf6\u0cfb\u0005", + "\u0126\u0094\u0002\u0cf7\u0cf8\u0007\b\u0002\u0002\u0cf8\u0cfa\u0005", + "\u0126\u0094\u0002\u0cf9\u0cf7\u0003\u0002\u0002\u0002\u0cfa\u0cfd\u0003", + "\u0002\u0002\u0002\u0cfb\u0cf9\u0003\u0002\u0002\u0002\u0cfb\u0cfc\u0003", + "\u0002\u0002\u0002\u0cfc\u0129\u0003\u0002\u0002\u0002\u0cfd\u0cfb\u0003", + "\u0002\u0002\u0002\u0cfe\u0cff\u00070\u0002\u0002\u0cff\u0d00\u0005", + "\u026c\u0137\u0002\u0d00\u0d01\u0005\u012c\u0097\u0002\u0d01\u0d02\u0005", + "\u0136\u009c\u0002\u0d02\u0d03\u0007\u00f0\u0002\u0002\u0d03\u0d09\u0005", + "\u0532\u029a\u0002\u0d04\u0d05\u0007\u00d9\u0002\u0002\u0d05\u0d06\u0005", + "\u012e\u0098\u0002\u0d06\u0d07\u0005\u0130\u0099\u0002\u0d07\u0d08\u0005", + "\u0134\u009b\u0002\u0d08\u0d0a\u0003\u0002\u0002\u0002\u0d09\u0d04\u0003", + "\u0002\u0002\u0002\u0d09\u0d0a\u0003\u0002\u0002\u0002\u0d0a\u012b\u0003", + "\u0002\u0002\u0002\u0d0b\u0d0e\u0007\u0160\u0002\u0002\u0d0c\u0d0e\u0003", + "\u0002\u0002\u0002\u0d0d\u0d0b\u0003\u0002\u0002\u0002\u0d0d\u0d0c\u0003", + "\u0002\u0002\u0002\u0d0e\u012d\u0003\u0002\u0002\u0002\u0d0f\u0d11\u0005", + "\u0532\u029a\u0002\u0d10\u0d12\u0005\u0210\u0109\u0002\u0d11\u0d10\u0003", + "\u0002\u0002\u0002\u0d11\u0d12\u0003\u0002\u0002\u0002\u0d12\u012f\u0003", + "\u0002\u0002\u0002\u0d13\u0d14\u0007\u00e8\u0002\u0002\u0d14\u0d17\u0005", + "\u012e\u0098\u0002\u0d15\u0d17\u0003\u0002\u0002\u0002\u0d16\u0d13\u0003", + "\u0002\u0002\u0002\u0d16\u0d15\u0003\u0002\u0002\u0002\u0d17\u0131\u0003", + "\u0002\u0002\u0002\u0d18\u0d19\u0007\u016e\u0002\u0002\u0d19\u0d1d\u0005", + "\u012e\u0098\u0002\u0d1a\u0d1b\u0007\u0106\u0002\u0002\u0d1b\u0d1d\u0007", + "\u016e\u0002\u0002\u0d1c\u0d18\u0003\u0002\u0002\u0002\u0d1c\u0d1a\u0003", + "\u0002\u0002\u0002\u0d1d\u0133\u0003\u0002\u0002\u0002\u0d1e\u0d21\u0005", + "\u0132\u009a\u0002\u0d1f\u0d21\u0003\u0002\u0002\u0002\u0d20\u0d1e\u0003", + "\u0002\u0002\u0002\u0d20\u0d1f\u0003\u0002\u0002\u0002\u0d21\u0135\u0003", + "\u0002\u0002\u0002\u0d22\u0d25\u0007\u0120\u0002\u0002\u0d23\u0d25\u0003", + "\u0002\u0002\u0002\u0d24\u0d22\u0003\u0002\u0002\u0002\u0d24\u0d23\u0003", + "\u0002\u0002\u0002\u0d25\u0137\u0003\u0002\u0002\u0002\u0d26\u0d27\u0007", + "0\u0002\u0002\u0d27\u0d28\u0007\u0158\u0002\u0002\u0d28\u0d29\u0005", + "\u0532\u029a\u0002\u0d29\u0d2a\u0005\u013a\u009e\u0002\u0d2a\u0d2b\u0007", + "\u00f8\u0002\u0002\u0d2b\u0d2c\u0005\u0544\u02a3\u0002\u0d2c\u0d2d\u0005", + "x=\u0002\u0d2d\u0139\u0003\u0002\u0002\u0002\u0d2e\u0d2f\u0007\u0113", + "\u0002\u0002\u0d2f\u0d32\u0005\u054e\u02a8\u0002\u0d30\u0d32\u0003\u0002", + "\u0002\u0002\u0d31\u0d2e\u0003\u0002\u0002\u0002\u0d31\u0d30\u0003\u0002", + "\u0002\u0002\u0d32\u013b\u0003\u0002\u0002\u0002\u0d33\u0d34\u0007\u00c1", + "\u0002\u0002\u0d34\u0d37\u0007\u0158\u0002\u0002\u0d35\u0d36\u0007\u00de", + "\u0002\u0002\u0d36\u0d38\u0007\u0185\u0002\u0002\u0d37\u0d35\u0003\u0002", + "\u0002\u0002\u0d37\u0d38\u0003\u0002\u0002\u0002\u0d38\u0d39\u0003\u0002", + "\u0002\u0002\u0d39\u0d3a\u0005\u0532\u029a\u0002\u0d3a\u013d\u0003\u0002", + "\u0002\u0002\u0d3b\u0d3c\u00070\u0002\u0002\u0d3c\u0d40\u0007\u00ce", + "\u0002\u0002\u0d3d\u0d3e\u0007\u00de\u0002\u0002\u0d3e\u0d3f\u0007O", + "\u0002\u0002\u0d3f\u0d41\u0007\u0185\u0002\u0002\u0d40\u0d3d\u0003\u0002", + "\u0002\u0002\u0d40\u0d41\u0003\u0002\u0002\u0002\u0d41\u0d42\u0003\u0002", + "\u0002\u0002\u0d42\u0d43\u0005\u0532\u029a\u0002\u0d43\u0d44\u0005\u0012", + "\n\u0002\u0d44\u0d45\u0005\u0140\u00a1\u0002\u0d45\u013f\u0003\u0002", + "\u0002\u0002\u0d46\u0d48\u0005\u0142\u00a2\u0002\u0d47\u0d46\u0003\u0002", + "\u0002\u0002\u0d48\u0d4b\u0003\u0002\u0002\u0002\u0d49\u0d47\u0003\u0002", + "\u0002\u0002\u0d49\u0d4a\u0003\u0002\u0002\u0002\u0d4a\u0141\u0003\u0002", + "\u0002\u0002\u0d4b\u0d49\u0003\u0002\u0002\u0002\u0d4c\u0d4d\u0007\u013c", + "\u0002\u0002\u0d4d\u0d54\u0005\u0532\u029a\u0002\u0d4e\u0d4f\u0007\u0170", + "\u0002\u0002\u0d4f\u0d54\u0005J&\u0002\u0d50\u0d51\u0007B\u0002\u0002", + "\u0d51\u0d54\u0005J&\u0002\u0d52\u0d54\u0007\u0098\u0002\u0002\u0d53", + "\u0d4c\u0003\u0002\u0002\u0002\u0d53\u0d4e\u0003\u0002\u0002\u0002\u0d53", + "\u0d50\u0003\u0002\u0002\u0002\u0d53\u0d52\u0003\u0002\u0002\u0002\u0d54", + "\u0143\u0003\u0002\u0002\u0002\u0d55\u0d56\u0007\u008c\u0002\u0002\u0d56", + "\u0d57\u0007\u00ce\u0002\u0002\u0d57\u0d58\u0005\u0532\u029a\u0002\u0d58", + "\u0d59\u0007\u016a\u0002\u0002\u0d59\u0d5a\u0005\u0146\u00a4\u0002\u0d5a", + "\u0145\u0003\u0002\u0002\u0002\u0d5b\u0d5d\u0005\u0148\u00a5\u0002\u0d5c", + "\u0d5b\u0003\u0002\u0002\u0002\u0d5d\u0d60\u0003\u0002\u0002\u0002\u0d5e", + "\u0d5c\u0003\u0002\u0002\u0002\u0d5e\u0d5f\u0003\u0002\u0002\u0002\u0d5f", + "\u0147\u0003\u0002\u0002\u0002\u0d60\u0d5e\u0003\u0002\u0002\u0002\u0d61", + "\u0d62\u0007`\u0002\u0002\u0d62\u0d63\u0005J&\u0002\u0d63\u0149\u0003", + "\u0002\u0002\u0002\u0d64\u0d65\u0007\u008c\u0002\u0002\u0d65\u0d66\u0007", + "\u00ce\u0002\u0002\u0d66\u0d67\u0005\u0532\u029a\u0002\u0d67\u0d68\u0005", + "*\u0016\u0002\u0d68\u0d69\u0005\u0206\u0104\u0002\u0d69\u0d6a\u0005", + "\u0532\u029a\u0002\u0d6a\u0dcd\u0003\u0002\u0002\u0002\u0d6b\u0d6c\u0007", + "\u008c\u0002\u0002\u0d6c\u0d6d\u0007\u00ce\u0002\u0002\u0d6d\u0d6e\u0005", + "\u0532\u029a\u0002\u0d6e\u0d6f\u0005*\u0016\u0002\u0d6f\u0d70\u0005", + "\u0204\u0103\u0002\u0d70\u0d71\u0005\u020e\u0108\u0002\u0d71\u0dcd\u0003", + "\u0002\u0002\u0002\u0d72\u0d73\u0007\u008c\u0002\u0002\u0d73\u0d74\u0007", + "\u00ce\u0002\u0002\u0d74\u0d75\u0005\u0532\u029a\u0002\u0d75\u0d76\u0005", + "*\u0016\u0002\u0d76\u0d77\u0007\u008a\u0002\u0002\u0d77\u0d78\u0005", + "\u028c\u0147\u0002\u0d78\u0dcd\u0003\u0002\u0002\u0002\u0d79\u0d7a\u0007", + "\u008c\u0002\u0002\u0d7a\u0d7b\u0007\u00ce\u0002\u0002\u0d7b\u0d7c\u0005", + "\u0532\u029a\u0002\u0d7c\u0d7d\u0005*\u0016\u0002\u0d7d\u0d7e\u0007", + "+\u0002\u0002\u0d7e\u0d7f\u0007\u0004\u0002\u0002\u0d7f\u0d80\u0005", + "\u0456\u022c\u0002\u0d80\u0d81\u0007&\u0002\u0002\u0d81\u0d82\u0005", + "\u0456\u022c\u0002\u0d82\u0d83\u0007\u0005\u0002\u0002\u0d83\u0dcd\u0003", + "\u0002\u0002\u0002\u0d84\u0d85\u0007\u008c\u0002\u0002\u0d85\u0d86\u0007", + "\u00ce\u0002\u0002\u0d86\u0d87\u0005\u0532\u029a\u0002\u0d87\u0d88\u0005", + "*\u0016\u0002\u0d88\u0d89\u0007\u00bf\u0002\u0002\u0d89\u0d8a\u0005", + "\u0456\u022c\u0002\u0d8a\u0dcd\u0003\u0002\u0002\u0002\u0d8b\u0d8c\u0007", + "\u008c\u0002\u0002\u0d8c\u0d8d\u0007\u00ce\u0002\u0002\u0d8d\u0d8e\u0005", + "\u0532\u029a\u0002\u0d8e\u0d8f\u0005*\u0016\u0002\u0d8f\u0d90\u0007", + "\u00d5\u0002\u0002\u0d90\u0d91\u0005\u0274\u013b\u0002\u0d91\u0dcd\u0003", + "\u0002\u0002\u0002\u0d92\u0d93\u0007\u008c\u0002\u0002\u0d93\u0d94\u0007", + "\u00ce\u0002\u0002\u0d94\u0d95\u0005\u0532\u029a\u0002\u0d95\u0d96\u0005", + "*\u0016\u0002\u0d96\u0d97\u0007\u010f\u0002\u0002\u0d97\u0d98\u0005", + "\u02b2\u015a\u0002\u0d98\u0dcd\u0003\u0002\u0002\u0002\u0d99\u0d9a\u0007", + "\u008c\u0002\u0002\u0d9a\u0d9b\u0007\u00ce\u0002\u0002\u0d9b\u0d9c\u0005", + "\u0532\u029a\u0002\u0d9c\u0d9d\u0005*\u0016\u0002\u0d9d\u0d9e\u0007", + "\u010f\u0002\u0002\u0d9e\u0d9f\u0007\u009e\u0002\u0002\u0d9f\u0da0\u0005", + "\u020e\u0108\u0002\u0da0\u0da1\u0007f\u0002\u0002\u0da1\u0da2\u0005", + "\u0532\u029a\u0002\u0da2\u0dcd\u0003\u0002\u0002\u0002\u0da3\u0da4\u0007", + "\u008c\u0002\u0002\u0da4\u0da5\u0007\u00ce\u0002\u0002\u0da5\u0da6\u0005", + "\u0532\u029a\u0002\u0da6\u0da7\u0005*\u0016\u0002\u0da7\u0da8\u0007", + "\u010f\u0002\u0002\u0da8\u0da9\u0007\u00d0\u0002\u0002\u0da9\u0daa\u0005", + "\u020e\u0108\u0002\u0daa\u0dab\u0007f\u0002\u0002\u0dab\u0dac\u0005", + "\u0532\u029a\u0002\u0dac\u0dcd\u0003\u0002\u0002\u0002\u0dad\u0dae\u0007", + "\u008c\u0002\u0002\u0dae\u0daf\u0007\u00ce\u0002\u0002\u0daf\u0db0\u0005", + "\u0532\u029a\u0002\u0db0\u0db1\u0005*\u0016\u0002\u0db1\u0db2\u0007", + "\u0121\u0002\u0002\u0db2\u0db3\u0005\u0274\u013b\u0002\u0db3\u0dcd\u0003", + "\u0002\u0002\u0002\u0db4\u0db5\u0007\u008c\u0002\u0002\u0db5\u0db6\u0007", + "\u00ce\u0002\u0002\u0db6\u0db7\u0005\u0532\u029a\u0002\u0db7\u0db8\u0005", + "*\u0016\u0002\u0db8\u0db9\u0007\u01b3\u0002\u0002\u0db9\u0dba\u0005", + "\u0274\u013b\u0002\u0dba\u0dcd\u0003\u0002\u0002\u0002\u0dbb\u0dbc\u0007", + "\u008c\u0002\u0002\u0dbc\u0dbd\u0007\u00ce\u0002\u0002\u0dbd\u0dbe\u0005", + "\u0532\u029a\u0002\u0dbe\u0dbf\u0005*\u0016\u0002\u0dbf\u0dc0\u0007", + "\u01b4\u0002\u0002\u0dc0\u0dc1\u0007@\u0002\u0002\u0dc1\u0dc2\u0005", + "\u0456\u022c\u0002\u0dc2\u0dc3\u0007\u00f0\u0002\u0002\u0dc3\u0dc4\u0005", + "\u0532\u029a\u0002\u0dc4\u0dcd\u0003\u0002\u0002\u0002\u0dc5\u0dc6\u0007", + "\u008c\u0002\u0002\u0dc6\u0dc7\u0007\u00ce\u0002\u0002\u0dc7\u0dc8\u0005", + "\u0532\u029a\u0002\u0dc8\u0dc9\u0005*\u0016\u0002\u0dc9\u0dca\u0007", + "\u0161\u0002\u0002\u0dca\u0dcb\u0005\u0456\u022c\u0002\u0dcb\u0dcd\u0003", + "\u0002\u0002\u0002\u0dcc\u0d64\u0003\u0002\u0002\u0002\u0dcc\u0d6b\u0003", + "\u0002\u0002\u0002\u0dcc\u0d72\u0003\u0002\u0002\u0002\u0dcc\u0d79\u0003", + "\u0002\u0002\u0002\u0dcc\u0d84\u0003\u0002\u0002\u0002\u0dcc\u0d8b\u0003", + "\u0002\u0002\u0002\u0dcc\u0d92\u0003\u0002\u0002\u0002\u0dcc\u0d99\u0003", + "\u0002\u0002\u0002\u0dcc\u0da3\u0003\u0002\u0002\u0002\u0dcc\u0dad\u0003", + "\u0002\u0002\u0002\u0dcc\u0db4\u0003\u0002\u0002\u0002\u0dcc\u0dbb\u0003", + "\u0002\u0002\u0002\u0dcc\u0dc5\u0003\u0002\u0002\u0002\u0dcd\u014b\u0003", + "\u0002\u0002\u0002\u0dce\u0dcf\u00070\u0002\u0002\u0dcf\u0dd0\u0007", + "A\u0002\u0002\u0dd0\u0dd1\u0007\u00b0\u0002\u0002\u0dd1\u0dd2\u0007", + "\u0176\u0002\u0002\u0dd2\u0dd3\u0005\u0532\u029a\u0002\u0dd3\u0dd4\u0005", + "\u0152\u00aa\u0002\u0dd4\u0dd5\u0005\u0156\u00ac\u0002\u0dd5\u014d\u0003", + "\u0002\u0002\u0002\u0dd6\u0dd7\u0007\u00d9\u0002\u0002\u0dd7\u0ddf\u0005", + "\u012e\u0098\u0002\u0dd8\u0dd9\u0007\u0106\u0002\u0002\u0dd9\u0ddf\u0007", + "\u00d9\u0002\u0002\u0dda\u0ddb\u0007\u016e\u0002\u0002\u0ddb\u0ddf\u0005", + "\u012e\u0098\u0002\u0ddc\u0ddd\u0007\u0106\u0002\u0002\u0ddd\u0ddf\u0007", + "\u016e\u0002\u0002\u0dde\u0dd6\u0003\u0002\u0002\u0002\u0dde\u0dd8\u0003", + "\u0002\u0002\u0002\u0dde\u0dda\u0003\u0002\u0002\u0002\u0dde\u0ddc\u0003", + "\u0002\u0002\u0002\u0ddf\u014f\u0003\u0002\u0002\u0002\u0de0\u0de2\u0005", + "\u014e\u00a8\u0002\u0de1\u0de0\u0003\u0002\u0002\u0002\u0de2\u0de3\u0003", + "\u0002\u0002\u0002\u0de3\u0de1\u0003\u0002\u0002\u0002\u0de3\u0de4\u0003", + "\u0002\u0002\u0002\u0de4\u0151\u0003\u0002\u0002\u0002\u0de5\u0de8\u0005", + "\u0150\u00a9\u0002\u0de6\u0de8\u0003\u0002\u0002\u0002\u0de7\u0de5\u0003", + "\u0002\u0002\u0002\u0de7\u0de6\u0003\u0002\u0002\u0002\u0de8\u0153\u0003", + "\u0002\u0002\u0002\u0de9\u0dea\u0007\u008c\u0002\u0002\u0dea\u0deb\u0007", + "A\u0002\u0002\u0deb\u0dec\u0007\u00b0\u0002\u0002\u0dec\u0ded\u0007", + "\u0176\u0002\u0002\u0ded\u0dee\u0005\u0532\u029a\u0002\u0dee\u0def\u0005", + "\u0152\u00aa\u0002\u0def\u0df0\u0005\u015a\u00ae\u0002\u0df0\u0df9\u0003", + "\u0002\u0002\u0002\u0df1\u0df2\u0007\u008c\u0002\u0002\u0df2\u0df3\u0007", + "A\u0002\u0002\u0df3\u0df4\u0007\u00b0\u0002\u0002\u0df4\u0df5\u0007", + "\u0176\u0002\u0002\u0df5\u0df6\u0005\u0532\u029a\u0002\u0df6\u0df7\u0005", + "\u0150\u00a9\u0002\u0df7\u0df9\u0003\u0002\u0002\u0002\u0df8\u0de9\u0003", + "\u0002\u0002\u0002\u0df8\u0df1\u0003\u0002\u0002\u0002\u0df9\u0155\u0003", + "\u0002\u0002\u0002\u0dfa\u0dfb\u0007\u0111\u0002\u0002\u0dfb\u0dfc\u0007", + "\u0004\u0002\u0002\u0dfc\u0dfd\u0005\u0158\u00ad\u0002\u0dfd\u0dfe\u0007", + "\u0005\u0002\u0002\u0dfe\u0e01\u0003\u0002\u0002\u0002\u0dff\u0e01\u0003", + "\u0002\u0002\u0002\u0e00\u0dfa\u0003\u0002\u0002\u0002\u0e00\u0dff\u0003", + "\u0002\u0002\u0002\u0e01\u0157\u0003\u0002\u0002\u0002\u0e02\u0e07\u0005", + "\u0160\u00b1\u0002\u0e03\u0e04\u0007\b\u0002\u0002\u0e04\u0e06\u0005", + "\u0160\u00b1\u0002\u0e05\u0e03\u0003\u0002\u0002\u0002\u0e06\u0e09\u0003", + "\u0002\u0002\u0002\u0e07\u0e05\u0003\u0002\u0002\u0002\u0e07\u0e08\u0003", + "\u0002\u0002\u0002\u0e08\u0159\u0003\u0002\u0002\u0002\u0e09\u0e07\u0003", + "\u0002\u0002\u0002\u0e0a\u0e0b\u0007\u0111\u0002\u0002\u0e0b\u0e0c\u0007", + "\u0004\u0002\u0002\u0e0c\u0e0d\u0005\u015c\u00af\u0002\u0e0d\u0e0e\u0007", + "\u0005\u0002\u0002\u0e0e\u015b\u0003\u0002\u0002\u0002\u0e0f\u0e14\u0005", + "\u015e\u00b0\u0002\u0e10\u0e11\u0007\b\u0002\u0002\u0e11\u0e13\u0005", + "\u015e\u00b0\u0002\u0e12\u0e10\u0003\u0002\u0002\u0002\u0e13\u0e16\u0003", + "\u0002\u0002\u0002\u0e14\u0e12\u0003\u0002\u0002\u0002\u0e14\u0e15\u0003", + "\u0002\u0002\u0002\u0e15\u015d\u0003\u0002\u0002\u0002\u0e16\u0e14\u0003", + "\u0002\u0002\u0002\u0e17\u0e1f\u0005\u0160\u00b1\u0002\u0e18\u0e19\u0007", + "\u0146\u0002\u0002\u0e19\u0e1f\u0005\u0160\u00b1\u0002\u0e1a\u0e1b\u0007", + "\u0087\u0002\u0002\u0e1b\u0e1f\u0005\u0160\u00b1\u0002\u0e1c\u0e1d\u0007", + "\u00c1\u0002\u0002\u0e1d\u0e1f\u0005\u0162\u00b2\u0002\u0e1e\u0e17\u0003", + "\u0002\u0002\u0002\u0e1e\u0e18\u0003\u0002\u0002\u0002\u0e1e\u0e1a\u0003", + "\u0002\u0002\u0002\u0e1e\u0e1c\u0003\u0002\u0002\u0002\u0e1f\u015f\u0003", + "\u0002\u0002\u0002\u0e20\u0e21\u0005\u0162\u00b2\u0002\u0e21\u0e22\u0005", + "\u0164\u00b3\u0002\u0e22\u0161\u0003\u0002\u0002\u0002\u0e23\u0e24\u0005", + "\u0558\u02ad\u0002\u0e24\u0163\u0003\u0002\u0002\u0002\u0e25\u0e26\u0005", + "\u0544\u02a3\u0002\u0e26\u0165\u0003\u0002\u0002\u0002\u0e27\u0e28\u0007", + "0\u0002\u0002\u0e28\u0e29\u0007\u0144\u0002\u0002\u0e29\u0e2a\u0005", + "\u0532\u029a\u0002\u0e2a\u0e2b\u0005\u0168\u00b5\u0002\u0e2b\u0e2c\u0005", + "\u016c\u00b7\u0002\u0e2c\u0e2d\u0007A\u0002\u0002\u0e2d\u0e2e\u0007", + "\u00b0\u0002\u0002\u0e2e\u0e2f\u0007\u0176\u0002\u0002\u0e2f\u0e30\u0005", + "\u0532\u029a\u0002\u0e30\u0e31\u0005\u0156\u00ac\u0002\u0e31\u0e41\u0003", + "\u0002\u0002\u0002\u0e32\u0e33\u00070\u0002\u0002\u0e33\u0e34\u0007", + "\u0144\u0002\u0002\u0e34\u0e35\u0007\u00de\u0002\u0002\u0e35\u0e36\u0007", + "O\u0002\u0002\u0e36\u0e37\u0007\u0185\u0002\u0002\u0e37\u0e38\u0005", + "\u0532\u029a\u0002\u0e38\u0e39\u0005\u0168\u00b5\u0002\u0e39\u0e3a\u0005", + "\u016c\u00b7\u0002\u0e3a\u0e3b\u0007A\u0002\u0002\u0e3b\u0e3c\u0007", + "\u00b0\u0002\u0002\u0e3c\u0e3d\u0007\u0176\u0002\u0002\u0e3d\u0e3e\u0005", + "\u0532\u029a\u0002\u0e3e\u0e3f\u0005\u0156\u00ac\u0002\u0e3f\u0e41\u0003", + "\u0002\u0002\u0002\u0e40\u0e27\u0003\u0002\u0002\u0002\u0e40\u0e32\u0003", + "\u0002\u0002\u0002\u0e41\u0167\u0003\u0002\u0002\u0002\u0e42\u0e43\u0007", + "\u0161\u0002\u0002\u0e43\u0e46\u0005\u0544\u02a3\u0002\u0e44\u0e46\u0003", + "\u0002\u0002\u0002\u0e45\u0e42\u0003\u0002\u0002\u0002\u0e45\u0e44\u0003", + "\u0002\u0002\u0002\u0e46\u0169\u0003\u0002\u0002\u0002\u0e47\u0e4a\u0007", + "\u0170\u0002\u0002\u0e48\u0e4b\u0005\u0544\u02a3\u0002\u0e49\u0e4b\u0007", + "P\u0002\u0002\u0e4a\u0e48\u0003\u0002\u0002\u0002\u0e4a\u0e49\u0003", + "\u0002\u0002\u0002\u0e4b\u016b\u0003\u0002\u0002\u0002\u0e4c\u0e4f\u0005", + "\u016a\u00b6\u0002\u0e4d\u0e4f\u0003\u0002\u0002\u0002\u0e4e\u0e4c\u0003", + "\u0002\u0002\u0002\u0e4e\u0e4d\u0003\u0002\u0002\u0002\u0e4f\u016d\u0003", + "\u0002\u0002\u0002\u0e50\u0e51\u0007\u008c\u0002\u0002\u0e51\u0e52\u0007", + "\u0144\u0002\u0002\u0e52\u0e58\u0005\u0532\u029a\u0002\u0e53\u0e59\u0005", + "\u015a\u00ae\u0002\u0e54\u0e56\u0005\u016a\u00b6\u0002\u0e55\u0e57\u0005", + "\u015a\u00ae\u0002\u0e56\u0e55\u0003\u0002\u0002\u0002\u0e56\u0e57\u0003", + "\u0002\u0002\u0002\u0e57\u0e59\u0003\u0002\u0002\u0002\u0e58\u0e53\u0003", + "\u0002\u0002\u0002\u0e58\u0e54\u0003\u0002\u0002\u0002\u0e59\u016f\u0003", + "\u0002\u0002\u0002\u0e5a\u0e5b\u00070\u0002\u0002\u0e5b\u0e5c\u0007", + "A\u0002\u0002\u0e5c\u0e5d\u0007^\u0002\u0002\u0e5d\u0e5e\u0005\u052e", + "\u0298\u0002\u0e5e\u0e5f\u0007\u0004\u0002\u0002\u0e5f\u0e60\u0005\u00b2", + "Z\u0002\u0e60\u0e61\u0007\u0005\u0002\u0002\u0e61\u0e62\u0005\u00f0", + "y\u0002\u0e62\u0e63\u0007\u0144\u0002\u0002\u0e63\u0e64\u0005\u0532", + "\u029a\u0002\u0e64\u0e65\u0005\u0156\u00ac\u0002\u0e65\u0e93\u0003\u0002", + "\u0002\u0002\u0e66\u0e67\u00070\u0002\u0002\u0e67\u0e68\u0007A\u0002", + "\u0002\u0e68\u0e69\u0007^\u0002\u0002\u0e69\u0e6a\u0007\u00de\u0002", + "\u0002\u0e6a\u0e6b\u0007O\u0002\u0002\u0e6b\u0e6c\u0007\u0185\u0002", + "\u0002\u0e6c\u0e6d\u0005\u052e\u0298\u0002\u0e6d\u0e6e\u0007\u0004\u0002", + "\u0002\u0e6e\u0e6f\u0005\u00b2Z\u0002\u0e6f\u0e70\u0007\u0005\u0002", + "\u0002\u0e70\u0e71\u0005\u00f0y\u0002\u0e71\u0e72\u0007\u0144\u0002", + "\u0002\u0e72\u0e73\u0005\u0532\u029a\u0002\u0e73\u0e74\u0005\u0156\u00ac", + "\u0002\u0e74\u0e93\u0003\u0002\u0002\u0002\u0e75\u0e76\u00070\u0002", + "\u0002\u0e76\u0e77\u0007A\u0002\u0002\u0e77\u0e78\u0007^\u0002\u0002", + "\u0e78\u0e79\u0005\u052e\u0298\u0002\u0e79\u0e7a\u0007\u0116\u0002\u0002", + "\u0e7a\u0e7b\u0007\u010c\u0002\u0002\u0e7b\u0e7c\u0005\u052e\u0298\u0002", + "\u0e7c\u0e7d\u0005\u00b4[\u0002\u0e7d\u0e7e\u0005\u0082B\u0002\u0e7e", + "\u0e7f\u0007\u0144\u0002\u0002\u0e7f\u0e80\u0005\u0532\u029a\u0002\u0e80", + "\u0e81\u0005\u0156\u00ac\u0002\u0e81\u0e93\u0003\u0002\u0002\u0002\u0e82", + "\u0e83\u00070\u0002\u0002\u0e83\u0e84\u0007A\u0002\u0002\u0e84\u0e85", + "\u0007^\u0002\u0002\u0e85\u0e86\u0007\u00de\u0002\u0002\u0e86\u0e87", + "\u0007O\u0002\u0002\u0e87\u0e88\u0007\u0185\u0002\u0002\u0e88\u0e89", + "\u0005\u052e\u0298\u0002\u0e89\u0e8a\u0007\u0116\u0002\u0002\u0e8a\u0e8b", + "\u0007\u010c\u0002\u0002\u0e8b\u0e8c\u0005\u052e\u0298\u0002\u0e8c\u0e8d", + "\u0005\u00b4[\u0002\u0e8d\u0e8e\u0005\u0082B\u0002\u0e8e\u0e8f\u0007", + "\u0144\u0002\u0002\u0e8f\u0e90\u0005\u0532\u029a\u0002\u0e90\u0e91\u0005", + "\u0156\u00ac\u0002\u0e91\u0e93\u0003\u0002\u0002\u0002\u0e92\u0e5a\u0003", + "\u0002\u0002\u0002\u0e92\u0e66\u0003\u0002\u0002\u0002\u0e92\u0e75\u0003", + "\u0002\u0002\u0002\u0e92\u0e82\u0003\u0002\u0002\u0002\u0e93\u0171\u0003", + "\u0002\u0002\u0002\u0e94\u0e95\u0007\u01b5\u0002\u0002\u0e95\u0e96\u0007", + "A\u0002\u0002\u0e96\u0e97\u0007\u013c\u0002\u0002\u0e97\u0e98\u0005", + "\u0532\u029a\u0002\u0e98\u0e99\u0005\u0176\u00bc\u0002\u0e99\u0e9a\u0007", + "B\u0002\u0002\u0e9a\u0e9b\u0007\u0144\u0002\u0002\u0e9b\u0e9c\u0005", + "\u0532\u029a\u0002\u0e9c\u0e9d\u0007I\u0002\u0002\u0e9d\u0e9e\u0005", + "\u0532\u029a\u0002\u0e9e\u0e9f\u0005\u0156\u00ac\u0002\u0e9f\u0173\u0003", + "\u0002\u0002\u0002\u0ea0\u0ea1\u0007L\u0002\u0002\u0ea1\u0ea4\u0007", + "`\u0002\u0002\u0ea2\u0ea4\u0007=\u0002\u0002\u0ea3\u0ea0\u0003\u0002", + "\u0002\u0002\u0ea3\u0ea2\u0003\u0002\u0002\u0002\u0ea4\u0175\u0003\u0002", + "\u0002\u0002\u0ea5\u0ea6\u0005\u0174\u00bb\u0002\u0ea6\u0ea7\u0007\u0004", + "\u0002\u0002\u0ea7\u0ea8\u0005\u042c\u0217\u0002\u0ea8\u0ea9\u0007\u0005", + "\u0002\u0002\u0ea9\u0eac\u0003\u0002\u0002\u0002\u0eaa\u0eac\u0003\u0002", + "\u0002\u0002\u0eab\u0ea5\u0003\u0002\u0002\u0002\u0eab\u0eaa\u0003\u0002", + "\u0002\u0002\u0eac\u0177\u0003\u0002\u0002\u0002\u0ead\u0eae\u00070", + "\u0002\u0002\u0eae\u0eaf\u0007e\u0002\u0002\u0eaf\u0eb0\u0007\u00fa", + "\u0002\u0002\u0eb0\u0eb1\u0007@\u0002\u0002\u0eb1\u0eb2\u0005\u017a", + "\u00be\u0002\u0eb2\u0eb3\u0007\u0144\u0002\u0002\u0eb3\u0eb4\u0005\u0532", + "\u029a\u0002\u0eb4\u0eb5\u0005\u0156\u00ac\u0002\u0eb5\u0ec3\u0003\u0002", + "\u0002\u0002\u0eb6\u0eb7\u00070\u0002\u0002\u0eb7\u0eb8\u0007e\u0002", + "\u0002\u0eb8\u0eb9\u0007\u00fa\u0002\u0002\u0eb9\u0eba\u0007\u00de\u0002", + "\u0002\u0eba\u0ebb\u0007O\u0002\u0002\u0ebb\u0ebc\u0007\u0185\u0002", + "\u0002\u0ebc\u0ebd\u0007@\u0002\u0002\u0ebd\u0ebe\u0005\u017a\u00be", + "\u0002\u0ebe\u0ebf\u0007\u0144\u0002\u0002\u0ebf\u0ec0\u0005\u0532\u029a", + "\u0002\u0ec0\u0ec1\u0005\u0156\u00ac\u0002\u0ec1\u0ec3\u0003\u0002\u0002", + "\u0002\u0ec2\u0ead\u0003\u0002\u0002\u0002\u0ec2\u0eb6\u0003\u0002\u0002", + "\u0002\u0ec3\u0179\u0003\u0002\u0002\u0002\u0ec4\u0ec7\u0005\u054e\u02a8", + "\u0002\u0ec5\u0ec7\u0007e\u0002\u0002\u0ec6\u0ec4\u0003\u0002\u0002", + "\u0002\u0ec6\u0ec5\u0003\u0002\u0002\u0002\u0ec7\u017b\u0003\u0002\u0002", + "\u0002\u0ec8\u0ec9\u0007\u00c1\u0002\u0002\u0ec9\u0eca\u0007e\u0002", + "\u0002\u0eca\u0ecb\u0007\u00fa\u0002\u0002\u0ecb\u0ecc\u0007@\u0002", + "\u0002\u0ecc\u0ecd\u0005\u017a\u00be\u0002\u0ecd\u0ece\u0007\u0144\u0002", + "\u0002\u0ece\u0ecf\u0005\u0532\u029a\u0002\u0ecf\u0edb\u0003\u0002\u0002", + "\u0002\u0ed0\u0ed1\u0007\u00c1\u0002\u0002\u0ed1\u0ed2\u0007e\u0002", + "\u0002\u0ed2\u0ed3\u0007\u00fa\u0002\u0002\u0ed3\u0ed4\u0007\u00de\u0002", + "\u0002\u0ed4\u0ed5\u0007\u0185\u0002\u0002\u0ed5\u0ed6\u0007@\u0002", + "\u0002\u0ed6\u0ed7\u0005\u017a\u00be\u0002\u0ed7\u0ed8\u0007\u0144\u0002", + "\u0002\u0ed8\u0ed9\u0005\u0532\u029a\u0002\u0ed9\u0edb\u0003\u0002\u0002", + "\u0002\u0eda\u0ec8\u0003\u0002\u0002\u0002\u0eda\u0ed0\u0003\u0002\u0002", + "\u0002\u0edb\u017d\u0003\u0002\u0002\u0002\u0edc\u0edd\u0007\u008c\u0002", + "\u0002\u0edd\u0ede\u0007e\u0002\u0002\u0ede\u0edf\u0007\u00fa\u0002", + "\u0002\u0edf\u0ee0\u0007@\u0002\u0002\u0ee0\u0ee1\u0005\u017a\u00be", + "\u0002\u0ee1\u0ee2\u0007\u0144\u0002\u0002\u0ee2\u0ee3\u0005\u0532\u029a", + "\u0002\u0ee3\u0ee4\u0005\u015a\u00ae\u0002\u0ee4\u017f\u0003\u0002\u0002", + "\u0002\u0ee5\u0ee6\u00070\u0002\u0002\u0ee6\u0ee7\u0007\u01b6\u0002", + "\u0002\u0ee7\u0ee8\u0005\u0532\u029a\u0002\u0ee8\u0ee9\u0007R\u0002", + "\u0002\u0ee9\u0eea\u0005\u052e\u0298\u0002\u0eea\u0eeb\u0005\u018c\u00c7", + "\u0002\u0eeb\u0eec\u0005\u018e\u00c8\u0002\u0eec\u0eed\u0005\u0188\u00c5", + "\u0002\u0eed\u0eee\u0005\u0184\u00c3\u0002\u0eee\u0eef\u0005\u0186\u00c4", + "\u0002\u0eef\u0181\u0003\u0002\u0002\u0002\u0ef0\u0ef1\u0007\u008c\u0002", + "\u0002\u0ef1\u0ef2\u0007\u01b6\u0002\u0002\u0ef2\u0ef3\u0005\u0532\u029a", + "\u0002\u0ef3\u0ef4\u0007R\u0002\u0002\u0ef4\u0ef5\u0005\u052e\u0298", + "\u0002\u0ef5\u0ef6\u0005\u018a\u00c6\u0002\u0ef6\u0ef7\u0005\u0184\u00c3", + "\u0002\u0ef7\u0ef8\u0005\u0186\u00c4\u0002\u0ef8\u0183\u0003\u0002\u0002", + "\u0002\u0ef9\u0efa\u0007f\u0002\u0002\u0efa\u0efb\u0007\u0004\u0002", + "\u0002\u0efb\u0efc\u0005\u0482\u0242\u0002\u0efc\u0efd\u0007\u0005\u0002", + "\u0002\u0efd\u0f00\u0003\u0002\u0002\u0002\u0efe\u0f00\u0003\u0002\u0002", + "\u0002\u0eff\u0ef9\u0003\u0002\u0002\u0002\u0eff\u0efe\u0003\u0002\u0002", + "\u0002\u0f00\u0185\u0003\u0002\u0002\u0002\u0f01\u0f02\u0007k\u0002", + "\u0002\u0f02\u0f03\u0007,\u0002\u0002\u0f03\u0f04\u0007\u0004\u0002", + "\u0002\u0f04\u0f05\u0005\u0482\u0242\u0002\u0f05\u0f06\u0007\u0005\u0002", + "\u0002\u0f06\u0f09\u0003\u0002\u0002\u0002\u0f07\u0f09\u0003\u0002\u0002", + "\u0002\u0f08\u0f01\u0003\u0002\u0002\u0002\u0f08\u0f07\u0003\u0002\u0002", + "\u0002\u0f09\u0187\u0003\u0002\u0002\u0002\u0f0a\u0f0b\u0007`\u0002", + "\u0002\u0f0b\u0f0e\u0005\u0550\u02a9\u0002\u0f0c\u0f0e\u0003\u0002\u0002", + "\u0002\u0f0d\u0f0a\u0003\u0002\u0002\u0002\u0f0d\u0f0c\u0003\u0002\u0002", + "\u0002\u0f0e\u0189\u0003\u0002\u0002\u0002\u0f0f\u0f10\u0007`\u0002", + "\u0002\u0f10\u0f13\u0005\u0550\u02a9\u0002\u0f11\u0f13\u0003\u0002\u0002", + "\u0002\u0f12\u0f0f\u0003\u0002\u0002\u0002\u0f12\u0f11\u0003\u0002\u0002", + "\u0002\u0f13\u018b\u0003\u0002\u0002\u0002\u0f14\u0f15\u0007&\u0002", + "\u0002\u0f15\u0f18\u0005\u055a\u02ae\u0002\u0f16\u0f18\u0003\u0002\u0002", + "\u0002\u0f17\u0f14\u0003\u0002\u0002\u0002\u0f17\u0f16\u0003\u0002\u0002", + "\u0002\u0f18\u018d\u0003\u0002\u0002\u0002\u0f19\u0f1a\u0007@\u0002", + "\u0002\u0f1a\u0f1d\u0005\u0190\u00c9\u0002\u0f1b\u0f1d\u0003\u0002\u0002", + "\u0002\u0f1c\u0f19\u0003\u0002\u0002\u0002\u0f1c\u0f1b\u0003\u0002\u0002", + "\u0002\u0f1d\u018f\u0003\u0002\u0002\u0002\u0f1e\u0f1f\t\u0013\u0002", + "\u0002\u0f1f\u0191\u0003\u0002\u0002\u0002\u0f20\u0f21\u00070\u0002", + "\u0002\u0f21\u0f22\u0007\u0085\u0002\u0002\u0f22\u0f23\u0007\u01b7\u0002", + "\u0002\u0f23\u0f24\u0005\u0532\u029a\u0002\u0f24\u0f25\u0007\u0161\u0002", + "\u0002\u0f25\u0f26\u0005\u0194\u00cb\u0002\u0f26\u0f27\u0007\u00d9\u0002", + "\u0002\u0f27\u0f28\u0005\u012e\u0098\u0002\u0f28\u0193\u0003\u0002\u0002", + "\u0002\u0f29\u0f2a\t\u0014\u0002\u0002\u0f2a\u0195\u0003\u0002\u0002", + "\u0002\u0f2b\u0f2c\u00070\u0002\u0002\u0f2c\u0f2d\u0007\u015e\u0002", + "\u0002\u0f2d\u0f2e\u0005\u0532\u029a\u0002\u0f2e\u0f2f\u0005\u0198\u00cd", + "\u0002\u0f2f\u0f30\u0005\u019a\u00ce\u0002\u0f30\u0f31\u0007R\u0002", + "\u0002\u0f31\u0f32\u0005\u052e\u0298\u0002\u0f32\u0f33\u0005\u019e\u00d0", + "\u0002\u0f33\u0f34\u0005\u01aa\u00d6\u0002\u0f34\u0f35\u0005\u01b0\u00d9", + "\u0002\u0f35\u0f36\u0007\u00cc\u0002\u0002\u0f36\u0f37\u0005\u01b2\u00da", + "\u0002\u0f37\u0f38\u0005\u0538\u029d\u0002\u0f38\u0f39\u0007\u0004\u0002", + "\u0002\u0f39\u0f3a\u0005\u01b4\u00db\u0002\u0f3a\u0f3b\u0007\u0005\u0002", + "\u0002\u0f3b\u0f52\u0003\u0002\u0002\u0002\u0f3c\u0f3d\u00070\u0002", + "\u0002\u0f3d\u0f3e\u0007/\u0002\u0002\u0f3e\u0f3f\u0007\u015e\u0002", + "\u0002\u0f3f\u0f40\u0005\u0532\u029a\u0002\u0f40\u0f41\u0007\u0089\u0002", + "\u0002\u0f41\u0f42\u0005\u019a\u00ce\u0002\u0f42\u0f43\u0007R\u0002", + "\u0002\u0f43\u0f44\u0005\u052e\u0298\u0002\u0f44\u0f45\u0005\u01b8\u00dd", + "\u0002\u0f45\u0f46\u0005\u01ba\u00de\u0002\u0f46\u0f47\u0007@\u0002", + "\u0002\u0f47\u0f48\u0007\u00c2\u0002\u0002\u0f48\u0f49\u0007\u0197\u0002", + "\u0002\u0f49\u0f4a\u0005\u01b0\u00d9\u0002\u0f4a\u0f4b\u0007\u00cc\u0002", + "\u0002\u0f4b\u0f4c\u0005\u01b2\u00da\u0002\u0f4c\u0f4d\u0005\u0538\u029d", + "\u0002\u0f4d\u0f4e\u0007\u0004\u0002\u0002\u0f4e\u0f4f\u0005\u01b4\u00db", + "\u0002\u0f4f\u0f50\u0007\u0005\u0002\u0002\u0f50\u0f52\u0003\u0002\u0002", + "\u0002\u0f51\u0f2b\u0003\u0002\u0002\u0002\u0f51\u0f3c\u0003\u0002\u0002", + "\u0002\u0f52\u0197\u0003\u0002\u0002\u0002\u0f53\u0f58\u0007\u0093\u0002", + "\u0002\u0f54\u0f58\u0007\u0089\u0002\u0002\u0f55\u0f56\u0007\u00eb\u0002", + "\u0002\u0f56\u0f58\u0007\u010c\u0002\u0002\u0f57\u0f53\u0003\u0002\u0002", + "\u0002\u0f57\u0f54\u0003\u0002\u0002\u0002\u0f57\u0f55\u0003\u0002\u0002", + "\u0002\u0f58\u0199\u0003\u0002\u0002\u0002\u0f59\u0f5e\u0005\u019c\u00cf", + "\u0002\u0f5a\u0f5b\u0007T\u0002\u0002\u0f5b\u0f5d\u0005\u019c\u00cf", + "\u0002\u0f5c\u0f5a\u0003\u0002\u0002\u0002\u0f5d\u0f60\u0003\u0002\u0002", + "\u0002\u0f5e\u0f5c\u0003\u0002\u0002\u0002\u0f5e\u0f5f\u0003\u0002\u0002", + "\u0002\u0f5f\u019b\u0003\u0002\u0002\u0002\u0f60\u0f5e\u0003\u0002\u0002", + "\u0002\u0f61\u0f69\u0007\u00ea\u0002\u0002\u0f62\u0f69\u0007\u00b8\u0002", + "\u0002\u0f63\u0f69\u0007\u016a\u0002\u0002\u0f64\u0f65\u0007\u016a\u0002", + "\u0002\u0f65\u0f66\u0007\u010c\u0002\u0002\u0f66\u0f69\u0005\u00dan", + "\u0002\u0f67\u0f69\u0007\u015f\u0002\u0002\u0f68\u0f61\u0003\u0002\u0002", + "\u0002\u0f68\u0f62\u0003\u0002\u0002\u0002\u0f68\u0f63\u0003\u0002\u0002", + "\u0002\u0f68\u0f64\u0003\u0002\u0002\u0002\u0f68\u0f67\u0003\u0002\u0002", + "\u0002\u0f69\u019d\u0003\u0002\u0002\u0002\u0f6a\u0f6b\u0007\u01b8\u0002", + "\u0002\u0f6b\u0f6e\u0005\u01a0\u00d1\u0002\u0f6c\u0f6e\u0003\u0002\u0002", + "\u0002\u0f6d\u0f6a\u0003\u0002\u0002\u0002\u0f6d\u0f6c\u0003\u0002\u0002", + "\u0002\u0f6e\u019f\u0003\u0002\u0002\u0002\u0f6f\u0f71\u0005\u01a2\u00d2", + "\u0002\u0f70\u0f6f\u0003\u0002\u0002\u0002\u0f71\u0f72\u0003\u0002\u0002", + "\u0002\u0f72\u0f70\u0003\u0002\u0002\u0002\u0f72\u0f73\u0003\u0002\u0002", + "\u0002\u0f73\u01a1\u0003\u0002\u0002\u0002\u0f74\u0f75\u0005\u01a4\u00d3", + "\u0002\u0f75\u0f76\u0005\u01a6\u00d4\u0002\u0f76\u0f77\u0005\u0344\u01a3", + "\u0002\u0f77\u0f78\u0005\u01a8\u00d5\u0002\u0f78\u01a3\u0003\u0002\u0002", + "\u0002\u0f79\u0f7a\t\u0015\u0002\u0002\u0f7a\u01a5\u0003\u0002\u0002", + "\u0002\u0f7b\u0f7c\t\u0016\u0002\u0002\u0f7c\u01a7\u0003\u0002\u0002", + "\u0002\u0f7d\u0f7e\u0005\u0552\u02aa\u0002\u0f7e\u01a9\u0003\u0002\u0002", + "\u0002\u0f7f\u0f80\u0007@\u0002\u0002\u0f80\u0f81\u0005\u01ac\u00d7", + "\u0002\u0f81\u0f82\u0005\u01ae\u00d8\u0002\u0f82\u0f85\u0003\u0002\u0002", + "\u0002\u0f83\u0f85\u0003\u0002\u0002\u0002\u0f84\u0f7f\u0003\u0002\u0002", + "\u0002\u0f84\u0f83\u0003\u0002\u0002\u0002\u0f85\u01ab\u0003\u0002\u0002", + "\u0002\u0f86\u0f89\u0007\u00c2\u0002\u0002\u0f87\u0f89\u0003\u0002\u0002", + "\u0002\u0f88\u0f86\u0003\u0002\u0002\u0002\u0f88\u0f87\u0003\u0002\u0002", + "\u0002\u0f89\u01ad\u0003\u0002\u0002\u0002\u0f8a\u0f8b\t\u0017\u0002", + "\u0002\u0f8b\u01af\u0003\u0002\u0002\u0002\u0f8c\u0f8d\u0007h\u0002", + "\u0002\u0f8d\u0f8e\u0007\u0004\u0002\u0002\u0f8e\u0f8f\u0005\u0482\u0242", + "\u0002\u0f8f\u0f90\u0007\u0005\u0002\u0002\u0f90\u0f93\u0003\u0002\u0002", + "\u0002\u0f91\u0f93\u0003\u0002\u0002\u0002\u0f92\u0f8c\u0003\u0002\u0002", + "\u0002\u0f92\u0f91\u0003\u0002\u0002\u0002\u0f93\u01b1\u0003\u0002\u0002", + "\u0002\u0f94\u0f95\t\u0018\u0002\u0002\u0f95\u01b3\u0003\u0002\u0002", + "\u0002\u0f96\u0f99\u0005\u01b6\u00dc\u0002\u0f97\u0f99\u0003\u0002\u0002", + "\u0002\u0f98\u0f96\u0003\u0002\u0002\u0002\u0f98\u0f97\u0003\u0002\u0002", + "\u0002\u0f99\u0f9e\u0003\u0002\u0002\u0002\u0f9a\u0f9b\u0007\b\u0002", + "\u0002\u0f9b\u0f9d\u0005\u01b6\u00dc\u0002\u0f9c\u0f9a\u0003\u0002\u0002", + "\u0002\u0f9d\u0fa0\u0003\u0002\u0002\u0002\u0f9e\u0f9c\u0003\u0002\u0002", + "\u0002\u0f9e\u0f9f\u0003\u0002\u0002\u0002\u0f9f\u01b5\u0003\u0002\u0002", + "\u0002\u0fa0\u0f9e\u0003\u0002\u0002\u0002\u0fa1\u0fa6\u0005\u0542\u02a2", + "\u0002\u0fa2\u0fa6\u0005\u0540\u02a1\u0002\u0fa3\u0fa6\u0005\u0544\u02a3", + "\u0002\u0fa4\u0fa6\u0005\u0558\u02ad\u0002\u0fa5\u0fa1\u0003\u0002\u0002", + "\u0002\u0fa5\u0fa2\u0003\u0002\u0002\u0002\u0fa5\u0fa3\u0003\u0002\u0002", + "\u0002\u0fa5\u0fa4\u0003\u0002\u0002\u0002\u0fa6\u01b7\u0003\u0002\u0002", + "\u0002\u0fa7\u0fa8\u0007B\u0002\u0002\u0fa8\u0fab\u0005\u052e\u0298", + "\u0002\u0fa9\u0fab\u0003\u0002\u0002\u0002\u0faa\u0fa7\u0003\u0002\u0002", + "\u0002\u0faa\u0fa9\u0003\u0002\u0002\u0002\u0fab\u01b9\u0003\u0002\u0002", + "\u0002\u0fac\u0fae\u0005\u01bc\u00df\u0002\u0fad\u0fac\u0003\u0002\u0002", + "\u0002\u0fae\u0fb1\u0003\u0002\u0002\u0002\u0faf\u0fad\u0003\u0002\u0002", + "\u0002\u0faf\u0fb0\u0003\u0002\u0002\u0002\u0fb0\u01bb\u0003\u0002\u0002", + "\u0002\u0fb1\u0faf\u0003\u0002\u0002\u0002\u0fb2\u0fb3\u0007O\u0002", + "\u0002\u0fb3\u0fbe\u00078\u0002\u0002\u0fb4\u0fbe\u00078\u0002\u0002", + "\u0fb5\u0fb6\u0007G\u0002\u0002\u0fb6\u0fbe\u0007\u00df\u0002\u0002", + "\u0fb7\u0fb8\u0007G\u0002\u0002\u0fb8\u0fbe\u0007\u00b6\u0002\u0002", + "\u0fb9\u0fba\u0007O\u0002\u0002\u0fba\u0fbe\u0007\u016c\u0002\u0002", + "\u0fbb\u0fbc\u0007\u0106\u0002\u0002\u0fbc\u0fbe\u0007\u00e6\u0002\u0002", + "\u0fbd\u0fb2\u0003\u0002\u0002\u0002\u0fbd\u0fb4\u0003\u0002\u0002\u0002", + "\u0fbd\u0fb5\u0003\u0002\u0002\u0002\u0fbd\u0fb7\u0003\u0002\u0002\u0002", + "\u0fbd\u0fb9\u0003\u0002\u0002\u0002\u0fbd\u0fbb\u0003\u0002\u0002\u0002", + "\u0fbe\u01bd\u0003\u0002\u0002\u0002\u0fbf\u0fc0\u00070\u0002\u0002", + "\u0fc0\u0fc1\u0007\u00c8\u0002\u0002\u0fc1\u0fc2\u0007\u015e\u0002\u0002", + "\u0fc2\u0fc3\u0005\u0532\u029a\u0002\u0fc3\u0fc4\u0007R\u0002\u0002", + "\u0fc4\u0fc5\u0005\u0558\u02ad\u0002\u0fc5\u0fc6\u0007\u00cc\u0002\u0002", + "\u0fc6\u0fc7\u0005\u01b2\u00da\u0002\u0fc7\u0fc8\u0005\u0538\u029d\u0002", + "\u0fc8\u0fc9\u0007\u0004\u0002\u0002\u0fc9\u0fca\u0007\u0005\u0002\u0002", + "\u0fca\u0fda\u0003\u0002\u0002\u0002\u0fcb\u0fcc\u00070\u0002\u0002", + "\u0fcc\u0fcd\u0007\u00c8\u0002\u0002\u0fcd\u0fce\u0007\u015e\u0002\u0002", + "\u0fce\u0fcf\u0005\u0532\u029a\u0002\u0fcf\u0fd0\u0007R\u0002\u0002", + "\u0fd0\u0fd1\u0005\u0558\u02ad\u0002\u0fd1\u0fd2\u0007h\u0002\u0002", + "\u0fd2\u0fd3\u0005\u01c0\u00e1\u0002\u0fd3\u0fd4\u0007\u00cc\u0002\u0002", + "\u0fd4\u0fd5\u0005\u01b2\u00da\u0002\u0fd5\u0fd6\u0005\u0538\u029d\u0002", + "\u0fd6\u0fd7\u0007\u0004\u0002\u0002\u0fd7\u0fd8\u0007\u0005\u0002\u0002", + "\u0fd8\u0fda\u0003\u0002\u0002\u0002\u0fd9\u0fbf\u0003\u0002\u0002\u0002", + "\u0fd9\u0fcb\u0003\u0002\u0002\u0002\u0fda\u01bf\u0003\u0002\u0002\u0002", + "\u0fdb\u0fe0\u0005\u01c2\u00e2\u0002\u0fdc\u0fdd\u0007#\u0002\u0002", + "\u0fdd\u0fdf\u0005\u01c2\u00e2\u0002\u0fde\u0fdc\u0003\u0002\u0002\u0002", + "\u0fdf\u0fe2\u0003\u0002\u0002\u0002\u0fe0\u0fde\u0003\u0002\u0002\u0002", + "\u0fe0\u0fe1\u0003\u0002\u0002\u0002\u0fe1\u01c1\u0003\u0002\u0002\u0002", + "\u0fe2\u0fe0\u0003\u0002\u0002\u0002\u0fe3\u0fe4\u0005\u0552\u02aa\u0002", + "\u0fe4\u0fe5\u0007F\u0002\u0002\u0fe5\u0fe6\u0007\u0004\u0002\u0002", + "\u0fe6\u0fe7\u0005\u01c4\u00e3\u0002\u0fe7\u0fe8\u0007\u0005\u0002\u0002", + "\u0fe8\u01c3\u0003\u0002\u0002\u0002\u0fe9\u0fee\u0005\u0544\u02a3\u0002", + "\u0fea\u0feb\u0007\b\u0002\u0002\u0feb\u0fed\u0005\u0544\u02a3\u0002", + "\u0fec\u0fea\u0003\u0002\u0002\u0002\u0fed\u0ff0\u0003\u0002\u0002\u0002", + "\u0fee\u0fec\u0003\u0002\u0002\u0002\u0fee\u0fef\u0003\u0002\u0002\u0002", + "\u0fef\u01c5\u0003\u0002\u0002\u0002\u0ff0\u0fee\u0003\u0002\u0002\u0002", + "\u0ff1\u0ff2\u0007\u008c\u0002\u0002\u0ff2\u0ff3\u0007\u00c8\u0002\u0002", + "\u0ff3\u0ff4\u0007\u015e\u0002\u0002\u0ff4\u0ff5\u0005\u0532\u029a\u0002", + "\u0ff5\u0ff6\u0005\u01c8\u00e5\u0002\u0ff6\u01c7\u0003\u0002\u0002\u0002", + "\u0ff7\u0ffe\u0007\u00c3\u0002\u0002\u0ff8\u0ff9\u0007\u00c3\u0002\u0002", + "\u0ff9\u0ffe\u0007\u0131\u0002\u0002\u0ffa\u0ffb\u0007\u00c3\u0002\u0002", + "\u0ffb\u0ffe\u0007\u008d\u0002\u0002\u0ffc\u0ffe\u0007\u00bc\u0002\u0002", + "\u0ffd\u0ff7\u0003\u0002\u0002\u0002\u0ffd\u0ff8\u0003\u0002\u0002\u0002", + "\u0ffd\u0ffa\u0003\u0002\u0002\u0002\u0ffd\u0ffc\u0003\u0002\u0002\u0002", + "\u0ffe\u01c9\u0003\u0002\u0002\u0002\u0fff\u1000\u00070\u0002\u0002", + "\u1000\u1001\u0007\u008e\u0002\u0002\u1001\u1002\u0005\u020e\u0108\u0002", + "\u1002\u1003\u0007,\u0002\u0002\u1003\u1004\u0007\u0004\u0002\u0002", + "\u1004\u1005\u0005\u0482\u0242\u0002\u1005\u1006\u0007\u0005\u0002\u0002", + "\u1006\u1007\u0005\u01ba\u00de\u0002\u1007\u01cb\u0003\u0002\u0002\u0002", + "\u1008\u1009\u00070\u0002\u0002\u1009\u100a\u0005\u026c\u0137\u0002", + "\u100a\u100b\u0007\u008a\u0002\u0002\u100b\u100c\u0005\u0538\u029d\u0002", + "\u100c\u100d\u0005\u0288\u0145\u0002\u100d\u100e\u0005\u01ce\u00e8\u0002", + "\u100e\u1073\u0003\u0002\u0002\u0002\u100f\u1010\u00070\u0002\u0002", + "\u1010\u1011\u0005\u026c\u0137\u0002\u1011\u1012\u0007\u008a\u0002\u0002", + "\u1012\u1013\u0005\u0538\u029d\u0002\u1013\u1014\u0005\u01d6\u00ec\u0002", + "\u1014\u1073\u0003\u0002\u0002\u0002\u1015\u1016\u00070\u0002\u0002", + "\u1016\u1017\u0007\u010f\u0002\u0002\u1017\u1018\u0005\u02ae\u0158\u0002", + "\u1018\u1019\u0005\u01ce\u00e8\u0002\u1019\u1073\u0003\u0002\u0002\u0002", + "\u101a\u101b\u00070\u0002\u0002\u101b\u101c\u0007\u0161\u0002\u0002", + "\u101c\u101d\u0005\u020e\u0108\u0002\u101d\u101e\u0005\u01ce\u00e8\u0002", + "\u101e\u1073\u0003\u0002\u0002\u0002\u101f\u1020\u00070\u0002\u0002", + "\u1020\u1021\u0007\u0161\u0002\u0002\u1021\u1073\u0005\u020e\u0108\u0002", + "\u1022\u1023\u00070\u0002\u0002\u1023\u1024\u0007\u0161\u0002\u0002", + "\u1024\u1025\u0005\u020e\u0108\u0002\u1025\u1026\u0007&\u0002\u0002", + "\u1026\u1027\u0007\u0004\u0002\u0002\u1027\u1028\u0005\u0442\u0222\u0002", + "\u1028\u1029\u0007\u0005\u0002\u0002\u1029\u1073\u0003\u0002\u0002\u0002", + "\u102a\u102b\u00070\u0002\u0002\u102b\u102c\u0007\u0161\u0002\u0002", + "\u102c\u102d\u0005\u020e\u0108\u0002\u102d\u102e\u0007&\u0002\u0002", + "\u102e\u102f\u0007\u00c6\u0002\u0002\u102f\u1030\u0007\u0004\u0002\u0002", + "\u1030\u1031\u0005\u01dc\u00ef\u0002\u1031\u1032\u0007\u0005\u0002\u0002", + "\u1032\u1073\u0003\u0002\u0002\u0002\u1033\u1034\u00070\u0002\u0002", + "\u1034\u1035\u0007\u0161\u0002\u0002\u1035\u1036\u0005\u020e\u0108\u0002", + "\u1036\u1037\u0007&\u0002\u0002\u1037\u1038\u0007\u0124\u0002\u0002", + "\u1038\u1039\u0005\u01ce\u00e8\u0002\u1039\u1073\u0003\u0002\u0002\u0002", + "\u103a\u103b\u00070\u0002\u0002\u103b\u103c\u0007\u015c\u0002\u0002", + "\u103c\u103d\u0007\u013e\u0002\u0002\u103d\u103e\u0007\u0114\u0002\u0002", + "\u103e\u103f\u0005\u020e\u0108\u0002\u103f\u1040\u0005\u01ce\u00e8\u0002", + "\u1040\u1073\u0003\u0002\u0002\u0002\u1041\u1042\u00070\u0002\u0002", + "\u1042\u1043\u0007\u015c\u0002\u0002\u1043\u1044\u0007\u013e\u0002\u0002", + "\u1044\u1045\u0007\u00bb\u0002\u0002\u1045\u1046\u0005\u020e\u0108\u0002", + "\u1046\u1047\u0005\u01ce\u00e8\u0002\u1047\u1073\u0003\u0002\u0002\u0002", + "\u1048\u1049\u00070\u0002\u0002\u1049\u104a\u0007\u015c\u0002\u0002", + "\u104a\u104b\u0007\u013e\u0002\u0002\u104b\u104c\u0007\u015a\u0002\u0002", + "\u104c\u104d\u0005\u020e\u0108\u0002\u104d\u104e\u0005\u01ce\u00e8\u0002", + "\u104e\u1073\u0003\u0002\u0002\u0002\u104f\u1050\u00070\u0002\u0002", + "\u1050\u1051\u0007\u015c\u0002\u0002\u1051\u1052\u0007\u013e\u0002\u0002", + "\u1052\u1053\u0007\u00a5\u0002\u0002\u1053\u1054\u0005\u020e\u0108\u0002", + "\u1054\u1055\u0005\u01ce\u00e8\u0002\u1055\u1073\u0003\u0002\u0002\u0002", + "\u1056\u1057\u00070\u0002\u0002\u1057\u1058\u0007n\u0002\u0002\u1058", + "\u1059\u0005\u020e\u0108\u0002\u1059\u105a\u0005\u01ce\u00e8\u0002\u105a", + "\u1073\u0003\u0002\u0002\u0002\u105b\u105c\u00070\u0002\u0002\u105c", + "\u105d\u0007n\u0002\u0002\u105d\u105e\u0007\u00de\u0002\u0002\u105e", + "\u105f\u0007O\u0002\u0002\u105f\u1060\u0007\u0185\u0002\u0002\u1060", + "\u1061\u0005\u020e\u0108\u0002\u1061\u1062\u0005\u01ce\u00e8\u0002\u1062", + "\u1073\u0003\u0002\u0002\u0002\u1063\u1064\u00070\u0002\u0002\u1064", + "\u1065\u0007n\u0002\u0002\u1065\u1066\u0005\u020e\u0108\u0002\u1066", + "\u1067\u0007B\u0002\u0002\u1067\u1068\u0005\u020e\u0108\u0002\u1068", + "\u1073\u0003\u0002\u0002\u0002\u1069\u106a\u00070\u0002\u0002\u106a", + "\u106b\u0007n\u0002\u0002\u106b\u106c\u0007\u00de\u0002\u0002\u106c", + "\u106d\u0007O\u0002\u0002\u106d\u106e\u0007\u0185\u0002\u0002\u106e", + "\u106f\u0005\u020e\u0108\u0002\u106f\u1070\u0007B\u0002\u0002\u1070", + "\u1071\u0005\u020e\u0108\u0002\u1071\u1073\u0003\u0002\u0002\u0002\u1072", + "\u1008\u0003\u0002\u0002\u0002\u1072\u100f\u0003\u0002\u0002\u0002\u1072", + "\u1015\u0003\u0002\u0002\u0002\u1072\u101a\u0003\u0002\u0002\u0002\u1072", + "\u101f\u0003\u0002\u0002\u0002\u1072\u1022\u0003\u0002\u0002\u0002\u1072", + "\u102a\u0003\u0002\u0002\u0002\u1072\u1033\u0003\u0002\u0002\u0002\u1072", + "\u103a\u0003\u0002\u0002\u0002\u1072\u1041\u0003\u0002\u0002\u0002\u1072", + "\u1048\u0003\u0002\u0002\u0002\u1072\u104f\u0003\u0002\u0002\u0002\u1072", + "\u1056\u0003\u0002\u0002\u0002\u1072\u105b\u0003\u0002\u0002\u0002\u1072", + "\u1063\u0003\u0002\u0002\u0002\u1072\u1069\u0003\u0002\u0002\u0002\u1073", + "\u01cd\u0003\u0002\u0002\u0002\u1074\u1075\u0007\u0004\u0002\u0002\u1075", + "\u1076\u0005\u01d0\u00e9\u0002\u1076\u1077\u0007\u0005\u0002\u0002\u1077", + "\u01cf\u0003\u0002\u0002\u0002\u1078\u107d\u0005\u01d2\u00ea\u0002\u1079", + "\u107a\u0007\b\u0002\u0002\u107a\u107c\u0005\u01d2\u00ea\u0002\u107b", + "\u1079\u0003\u0002\u0002\u0002\u107c\u107f\u0003\u0002\u0002\u0002\u107d", + "\u107b\u0003\u0002\u0002\u0002\u107d\u107e\u0003\u0002\u0002\u0002\u107e", + "\u01d1\u0003\u0002\u0002\u0002\u107f\u107d\u0003\u0002\u0002\u0002\u1080", + "\u1083\u0005\u0558\u02ad\u0002\u1081\u1082\u0007\f\u0002\u0002\u1082", + "\u1084\u0005\u01d4\u00eb\u0002\u1083\u1081\u0003\u0002\u0002\u0002\u1083", + "\u1084\u0003\u0002\u0002\u0002\u1084\u01d3\u0003\u0002\u0002\u0002\u1085", + "\u108c\u0005\u0282\u0142\u0002\u1086\u108c\u0005\u0564\u02b3\u0002\u1087", + "\u108c\u0005\u04f2\u027a\u0002\u1088\u108c\u0005\u0126\u0094\u0002\u1089", + "\u108c\u0005\u0544\u02a3\u0002\u108a\u108c\u0007\u0190\u0002\u0002\u108b", + "\u1085\u0003\u0002\u0002\u0002\u108b\u1086\u0003\u0002\u0002\u0002\u108b", + "\u1087\u0003\u0002\u0002\u0002\u108b\u1088\u0003\u0002\u0002\u0002\u108b", + "\u1089\u0003\u0002\u0002\u0002\u108b\u108a\u0003\u0002\u0002\u0002\u108c", + "\u01d5\u0003\u0002\u0002\u0002\u108d\u108e\u0007\u0004\u0002\u0002\u108e", + "\u108f\u0005\u01d8\u00ed\u0002\u108f\u1090\u0007\u0005\u0002\u0002\u1090", + "\u01d7\u0003\u0002\u0002\u0002\u1091\u1096\u0005\u01da\u00ee\u0002\u1092", + "\u1093\u0007\b\u0002\u0002\u1093\u1095\u0005\u01da\u00ee\u0002\u1094", + "\u1092\u0003\u0002\u0002\u0002\u1095\u1098\u0003\u0002\u0002\u0002\u1096", + "\u1094\u0003\u0002\u0002\u0002\u1096\u1097\u0003\u0002\u0002\u0002\u1097", + "\u01d9\u0003\u0002\u0002\u0002\u1098\u1096\u0003\u0002\u0002\u0002\u1099", + "\u109a\u0005\u055a\u02ae\u0002\u109a\u109b\u0007\f\u0002\u0002\u109b", + "\u109c\u0005\u01d4\u00eb\u0002\u109c\u01db\u0003\u0002\u0002\u0002\u109d", + "\u10a0\u0005\u01de\u00f0\u0002\u109e\u10a0\u0003\u0002\u0002\u0002\u109f", + "\u109d\u0003\u0002\u0002\u0002\u109f\u109e\u0003\u0002\u0002\u0002\u10a0", + "\u01dd\u0003\u0002\u0002\u0002\u10a1\u10a6\u0005\u0544\u02a3\u0002\u10a2", + "\u10a3\u0007\b\u0002\u0002\u10a3\u10a5\u0005\u0544\u02a3\u0002\u10a4", + "\u10a2\u0003\u0002\u0002\u0002\u10a5\u10a8\u0003\u0002\u0002\u0002\u10a6", + "\u10a4\u0003\u0002\u0002\u0002\u10a6\u10a7\u0003\u0002\u0002\u0002\u10a7", + "\u01df\u0003\u0002\u0002\u0002\u10a8\u10a6\u0003\u0002\u0002\u0002\u10a9", + "\u10aa\u0007\u008c\u0002\u0002\u10aa\u10ab\u0007\u0161\u0002\u0002\u10ab", + "\u10ac\u0005\u020e\u0108\u0002\u10ac\u10ad\u0007\u0087\u0002\u0002\u10ad", + "\u10ae\u0007\u01bb\u0002\u0002\u10ae\u10af\u0005\u01e2\u00f2\u0002\u10af", + "\u10b0\u0005\u0544\u02a3\u0002\u10b0\u10cf\u0003\u0002\u0002\u0002\u10b1", + "\u10b2\u0007\u008c\u0002\u0002\u10b2\u10b3\u0007\u0161\u0002\u0002\u10b3", + "\u10b4\u0005\u020e\u0108\u0002\u10b4\u10b5\u0007\u0087\u0002\u0002\u10b5", + "\u10b6\u0007\u01bb\u0002\u0002\u10b6\u10b7\u0005\u01e2\u00f2\u0002\u10b7", + "\u10b8\u0005\u0544\u02a3\u0002\u10b8\u10b9\u0007\u0093\u0002\u0002\u10b9", + "\u10ba\u0005\u0544\u02a3\u0002\u10ba\u10cf\u0003\u0002\u0002\u0002\u10bb", + "\u10bc\u0007\u008c\u0002\u0002\u10bc\u10bd\u0007\u0161\u0002\u0002\u10bd", + "\u10be\u0005\u020e\u0108\u0002\u10be\u10bf\u0007\u0087\u0002\u0002\u10bf", + "\u10c0\u0007\u01bb\u0002\u0002\u10c0\u10c1\u0005\u01e2\u00f2\u0002\u10c1", + "\u10c2\u0005\u0544\u02a3\u0002\u10c2\u10c3\u0007\u0089\u0002\u0002\u10c3", + "\u10c4\u0005\u0544\u02a3\u0002\u10c4\u10cf\u0003\u0002\u0002\u0002\u10c5", + "\u10c6\u0007\u008c\u0002\u0002\u10c6\u10c7\u0007\u0161\u0002\u0002\u10c7", + "\u10c8\u0005\u020e\u0108\u0002\u10c8\u10c9\u0007\u012e\u0002\u0002\u10c9", + "\u10ca\u0007\u01bb\u0002\u0002\u10ca\u10cb\u0005\u0544\u02a3\u0002\u10cb", + "\u10cc\u0007`\u0002\u0002\u10cc\u10cd\u0005\u0544\u02a3\u0002\u10cd", + "\u10cf\u0003\u0002\u0002\u0002\u10ce\u10a9\u0003\u0002\u0002\u0002\u10ce", + "\u10b1\u0003\u0002\u0002\u0002\u10ce\u10bb\u0003\u0002\u0002\u0002\u10ce", + "\u10c5\u0003\u0002\u0002\u0002\u10cf\u01e1\u0003\u0002\u0002\u0002\u10d0", + "\u10d1\u0007\u00de\u0002\u0002\u10d1\u10d2\u0007O\u0002\u0002\u10d2", + "\u10d5\u0007\u0185\u0002\u0002\u10d3\u10d5\u0003\u0002\u0002\u0002\u10d4", + "\u10d0\u0003\u0002\u0002\u0002\u10d4\u10d3\u0003\u0002\u0002\u0002\u10d5", + "\u01e3\u0003\u0002\u0002\u0002\u10d6\u10d7\u00070\u0002\u0002\u10d7", + "\u10d8\u0007\u010f\u0002\u0002\u10d8\u10d9\u0007\u009e\u0002\u0002\u10d9", + "\u10da\u0005\u020e\u0108\u0002\u10da\u10db\u0005\u01ea\u00f6\u0002\u10db", + "\u10dc\u0007@\u0002\u0002\u10dc\u10dd\u0007\u0161\u0002\u0002\u10dd", + "\u10de\u0005\u0456\u022c\u0002\u10de\u10df\u0007f\u0002\u0002\u10df", + "\u10e0\u0005\u0532\u029a\u0002\u10e0\u10e1\u0005\u01ec\u00f7\u0002\u10e1", + "\u10e2\u0007&\u0002\u0002\u10e2\u10e3\u0005\u01e6\u00f4\u0002\u10e3", + "\u01e5\u0003\u0002\u0002\u0002\u10e4\u10e9\u0005\u01e8\u00f5\u0002\u10e5", + "\u10e6\u0007\b\u0002\u0002\u10e6\u10e8\u0005\u01e8\u00f5\u0002\u10e7", + "\u10e5\u0003\u0002\u0002\u0002\u10e8\u10eb\u0003\u0002\u0002\u0002\u10e9", + "\u10e7\u0003\u0002\u0002\u0002\u10e9\u10ea\u0003\u0002\u0002\u0002\u10ea", + "\u01e7\u0003\u0002\u0002\u0002\u10eb\u10e9\u0003\u0002\u0002\u0002\u10ec", + "\u10ed\u0007\u010f\u0002\u0002\u10ed\u10ee\u0005\u0542\u02a2\u0002\u10ee", + "\u10ef\u0005\u02ae\u0158\u0002\u10ef\u10f0\u0005\u01ee\u00f8\u0002\u10f0", + "\u10f1\u0005\u01f0\u00f9\u0002\u10f1\u1106\u0003\u0002\u0002\u0002\u10f2", + "\u10f3\u0007\u010f\u0002\u0002\u10f3\u10f4\u0005\u0542\u02a2\u0002\u10f4", + "\u10f5\u0005\u02b2\u015a\u0002\u10f5\u10f6\u0005\u01ee\u00f8\u0002\u10f6", + "\u10f7\u0005\u01f0\u00f9\u0002\u10f7\u1106\u0003\u0002\u0002\u0002\u10f8", + "\u10f9\u0007\u00d5\u0002\u0002\u10f9\u10fa\u0005\u0542\u02a2\u0002\u10fa", + "\u10fb\u0005\u0274\u013b\u0002\u10fb\u1106\u0003\u0002\u0002\u0002\u10fc", + "\u10fd\u0007\u00d5\u0002\u0002\u10fd\u10fe\u0005\u0542\u02a2\u0002\u10fe", + "\u10ff\u0007\u0004\u0002\u0002\u10ff\u1100\u0005\u04fc\u027f\u0002\u1100", + "\u1101\u0007\u0005\u0002\u0002\u1101\u1102\u0005\u0274\u013b\u0002\u1102", + "\u1106\u0003\u0002\u0002\u0002\u1103\u1104\u0007\u0152\u0002\u0002\u1104", + "\u1106\u0005\u0456\u022c\u0002\u1105\u10ec\u0003\u0002\u0002\u0002\u1105", + "\u10f2\u0003\u0002\u0002\u0002\u1105\u10f8\u0003\u0002\u0002\u0002\u1105", + "\u10fc\u0003\u0002\u0002\u0002\u1105\u1103\u0003\u0002\u0002\u0002\u1106", + "\u01e9\u0003\u0002\u0002\u0002\u1107\u110a\u00077\u0002\u0002\u1108", + "\u110a\u0003\u0002\u0002\u0002\u1109\u1107\u0003\u0002\u0002\u0002\u1109", + "\u1108\u0003\u0002\u0002\u0002\u110a\u01eb\u0003\u0002\u0002\u0002\u110b", + "\u110c\u0007\u00d0\u0002\u0002\u110c\u110f\u0005\u020e\u0108\u0002\u110d", + "\u110f\u0003\u0002\u0002\u0002\u110e\u110b\u0003\u0002\u0002\u0002\u110e", + "\u110d\u0003\u0002\u0002\u0002\u110f\u01ed\u0003\u0002\u0002\u0002\u1110", + "\u1111\u0007@\u0002\u0002\u1111\u1118\u0007\u013e\u0002\u0002\u1112", + "\u1113\u0007@\u0002\u0002\u1113\u1114\u0007U\u0002\u0002\u1114\u1115", + "\u0007\u0095\u0002\u0002\u1115\u1118\u0005\u020e\u0108\u0002\u1116\u1118", + "\u0003\u0002\u0002\u0002\u1117\u1110\u0003\u0002\u0002\u0002\u1117\u1112", + "\u0003\u0002\u0002\u0002\u1117\u1116\u0003\u0002\u0002\u0002\u1118\u01ef", + "\u0003\u0002\u0002\u0002\u1119\u111c\u0007\u0127\u0002\u0002\u111a\u111c", + "\u0003\u0002\u0002\u0002\u111b\u1119\u0003\u0002\u0002\u0002\u111b\u111a", + "\u0003\u0002\u0002\u0002\u111c\u01f1\u0003\u0002\u0002\u0002\u111d\u111e", + "\u00070\u0002\u0002\u111e\u111f\u0007\u010f\u0002\u0002\u111f\u1120", + "\u0007\u00d0\u0002\u0002\u1120\u1121\u0005\u020e\u0108\u0002\u1121\u1122", + "\u0007f\u0002\u0002\u1122\u1123\u0005\u0532\u029a\u0002\u1123\u01f3", + "\u0003\u0002\u0002\u0002\u1124\u1125\u0007\u008c\u0002\u0002\u1125\u1126", + "\u0007\u010f\u0002\u0002\u1126\u1127\u0007\u00d0\u0002\u0002\u1127\u1128", + "\u0005\u020e\u0108\u0002\u1128\u1129\u0007f\u0002\u0002\u1129\u112a", + "\u0005\u0532\u029a\u0002\u112a\u112b\u0007\u0087\u0002\u0002\u112b\u112c", + "\u0005\u01e6\u00f4\u0002\u112c\u1137\u0003\u0002\u0002\u0002\u112d\u112e", + "\u0007\u008c\u0002\u0002\u112e\u112f\u0007\u010f\u0002\u0002\u112f\u1130", + "\u0007\u00d0\u0002\u0002\u1130\u1131\u0005\u020e\u0108\u0002\u1131\u1132", + "\u0007f\u0002\u0002\u1132\u1133\u0005\u0532\u029a\u0002\u1133\u1134", + "\u0007\u00c1\u0002\u0002\u1134\u1135\u0005\u01f6\u00fc\u0002\u1135\u1137", + "\u0003\u0002\u0002\u0002\u1136\u1124\u0003\u0002\u0002\u0002\u1136\u112d", + "\u0003\u0002\u0002\u0002\u1137\u01f5\u0003\u0002\u0002\u0002\u1138\u113d", + "\u0005\u01f8\u00fd\u0002\u1139\u113a\u0007\b\u0002\u0002\u113a\u113c", + "\u0005\u01f8\u00fd\u0002\u113b\u1139\u0003\u0002\u0002\u0002\u113c\u113f", + "\u0003\u0002\u0002\u0002\u113d\u113b\u0003\u0002\u0002\u0002\u113d\u113e", + "\u0003\u0002\u0002\u0002\u113e\u01f7\u0003\u0002\u0002\u0002\u113f\u113d", + "\u0003\u0002\u0002\u0002\u1140\u1141\u0007\u010f\u0002\u0002\u1141\u1142", + "\u0005\u0542\u02a2\u0002\u1142\u1143\u0007\u0004\u0002\u0002\u1143\u1144", + "\u0005\u04fc\u027f\u0002\u1144\u1145\u0007\u0005\u0002\u0002\u1145\u114d", + "\u0003\u0002\u0002\u0002\u1146\u1147\u0007\u00d5\u0002\u0002\u1147\u1148", + "\u0005\u0542\u02a2\u0002\u1148\u1149\u0007\u0004\u0002\u0002\u1149\u114a", + "\u0005\u04fc\u027f\u0002\u114a\u114b\u0007\u0005\u0002\u0002\u114b\u114d", + "\u0003\u0002\u0002\u0002\u114c\u1140\u0003\u0002\u0002\u0002\u114c\u1146", + "\u0003\u0002\u0002\u0002\u114d\u01f9\u0003\u0002\u0002\u0002\u114e\u114f", + "\u0007\u00c1\u0002\u0002\u114f\u1150\u0007\u010f\u0002\u0002\u1150\u1151", + "\u0007\u009e\u0002\u0002\u1151\u1152\u0005\u020e\u0108\u0002\u1152\u1153", + "\u0007f\u0002\u0002\u1153\u1154\u0005\u0532\u029a\u0002\u1154\u1155", + "\u0005n8\u0002\u1155\u1161\u0003\u0002\u0002\u0002\u1156\u1157\u0007", + "\u00c1\u0002\u0002\u1157\u1158\u0007\u010f\u0002\u0002\u1158\u1159\u0007", + "\u009e\u0002\u0002\u1159\u115a\u0007\u00de\u0002\u0002\u115a\u115b\u0007", + "\u0185\u0002\u0002\u115b\u115c\u0005\u020e\u0108\u0002\u115c\u115d\u0007", + "f\u0002\u0002\u115d\u115e\u0005\u0532\u029a\u0002\u115e\u115f\u0005", + "n8\u0002\u115f\u1161\u0003\u0002\u0002\u0002\u1160\u114e\u0003\u0002", + "\u0002\u0002\u1160\u1156\u0003\u0002\u0002\u0002\u1161\u01fb\u0003\u0002", + "\u0002\u0002\u1162\u1163\u0007\u00c1\u0002\u0002\u1163\u1164\u0007\u010f", + "\u0002\u0002\u1164\u1165\u0007\u00d0\u0002\u0002\u1165\u1166\u0005\u020e", + "\u0108\u0002\u1166\u1167\u0007f\u0002\u0002\u1167\u1168\u0005\u0532", + "\u029a\u0002\u1168\u1169\u0005n8\u0002\u1169\u1175\u0003\u0002\u0002", + "\u0002\u116a\u116b\u0007\u00c1\u0002\u0002\u116b\u116c\u0007\u010f\u0002", + "\u0002\u116c\u116d\u0007\u00d0\u0002\u0002\u116d\u116e\u0007\u00de\u0002", + "\u0002\u116e\u116f\u0007\u0185\u0002\u0002\u116f\u1170\u0005\u020e\u0108", + "\u0002\u1170\u1171\u0007f\u0002\u0002\u1171\u1172\u0005\u0532\u029a", + "\u0002\u1172\u1173\u0005n8\u0002\u1173\u1175\u0003\u0002\u0002\u0002", + "\u1174\u1162\u0003\u0002\u0002\u0002\u1174\u116a\u0003\u0002\u0002\u0002", + "\u1175\u01fd\u0003\u0002\u0002\u0002\u1176\u1177\u0007\u00c1\u0002\u0002", + "\u1177\u1178\u0007\u0112\u0002\u0002\u1178\u1179\u0007\u0095\u0002\u0002", + "\u1179\u117a\u0005\u0550\u02a9\u0002\u117a\u117b\u0005n8\u0002\u117b", + "\u01ff\u0003\u0002\u0002\u0002\u117c\u117d\u0007\u0126\u0002\u0002\u117d", + "\u117e\u0007\u0112\u0002\u0002\u117e\u117f\u0007\u0095\u0002\u0002\u117f", + "\u1180\u0005\u0550\u02a9\u0002\u1180\u1181\u0007`\u0002\u0002\u1181", + "\u1182\u0005\u054e\u02a8\u0002\u1182\u0201\u0003\u0002\u0002\u0002\u1183", + "\u1184\u0007\u00c1\u0002\u0002\u1184\u1185\u0005\u0204\u0103\u0002\u1185", + "\u1186\u0007\u00de\u0002\u0002\u1186\u1187\u0007\u0185\u0002\u0002\u1187", + "\u1188\u0005\u020c\u0107\u0002\u1188\u1189\u0005n8\u0002\u1189\u11d2", + "\u0003\u0002\u0002\u0002\u118a\u118b\u0007\u00c1\u0002\u0002\u118b\u118c", + "\u0005\u0204\u0103\u0002\u118c\u118d\u0005\u020c\u0107\u0002\u118d\u118e", + "\u0005n8\u0002\u118e\u11d2\u0003\u0002\u0002\u0002\u118f\u1190\u0007", + "\u00c1\u0002\u0002\u1190\u1191\u0005\u0208\u0105\u0002\u1191\u1192\u0007", + "\u00de\u0002\u0002\u1192\u1193\u0007\u0185\u0002\u0002\u1193\u1194\u0005", + "\u0530\u0299\u0002\u1194\u1195\u0005n8\u0002\u1195\u11d2\u0003\u0002", + "\u0002\u0002\u1196\u1197\u0007\u00c1\u0002\u0002\u1197\u1198\u0005\u0208", + "\u0105\u0002\u1198\u1199\u0005\u0530\u0299\u0002\u1199\u119a\u0005n", + "8\u0002\u119a\u11d2\u0003\u0002\u0002\u0002\u119b\u119c\u0007\u00c1", + "\u0002\u0002\u119c\u119d\u0005\u020a\u0106\u0002\u119d\u119e\u0005\u0532", + "\u029a\u0002\u119e\u119f\u0007R\u0002\u0002\u119f\u11a0\u0005\u020e", + "\u0108\u0002\u11a0\u11a1\u0005n8\u0002\u11a1\u11d2\u0003\u0002\u0002", + "\u0002\u11a2\u11a3\u0007\u00c1\u0002\u0002\u11a3\u11a4\u0005\u020a\u0106", + "\u0002\u11a4\u11a5\u0007\u00de\u0002\u0002\u11a5\u11a6\u0007\u0185\u0002", + "\u0002\u11a6\u11a7\u0005\u0532\u029a\u0002\u11a7\u11a8\u0007R\u0002", + "\u0002\u11a8\u11a9\u0005\u020e\u0108\u0002\u11a9\u11aa\u0005n8\u0002", + "\u11aa\u11d2\u0003\u0002\u0002\u0002\u11ab\u11ac\u0007\u00c1\u0002\u0002", + "\u11ac\u11ad\u0007\u0161\u0002\u0002\u11ad\u11ae\u0005\u0212\u010a\u0002", + "\u11ae\u11af\u0005n8\u0002\u11af\u11d2\u0003\u0002\u0002\u0002\u11b0", + "\u11b1\u0007\u00c1\u0002\u0002\u11b1\u11b2\u0007\u0161\u0002\u0002\u11b2", + "\u11b3\u0007\u00de\u0002\u0002\u11b3\u11b4\u0007\u0185\u0002\u0002\u11b4", + "\u11b5\u0005\u0212\u010a\u0002\u11b5\u11b6\u0005n8\u0002\u11b6\u11d2", + "\u0003\u0002\u0002\u0002\u11b7\u11b8\u0007\u00c1\u0002\u0002\u11b8\u11b9", + "\u0007\u00bf\u0002\u0002\u11b9\u11ba\u0005\u0212\u010a\u0002\u11ba\u11bb", + "\u0005n8\u0002\u11bb\u11d2\u0003\u0002\u0002\u0002\u11bc\u11bd\u0007", + "\u00c1\u0002\u0002\u11bd\u11be\u0007\u00bf\u0002\u0002\u11be\u11bf\u0007", + "\u00de\u0002\u0002\u11bf\u11c0\u0007\u0185\u0002\u0002\u11c0\u11c1\u0005", + "\u0212\u010a\u0002\u11c1\u11c2\u0005n8\u0002\u11c2\u11d2\u0003\u0002", + "\u0002\u0002\u11c3\u11c4\u0007\u00c1\u0002\u0002\u11c4\u11c5\u0007\u00e4", + "\u0002\u0002\u11c5\u11c6\u0007o\u0002\u0002\u11c6\u11c7\u0005\u020c", + "\u0107\u0002\u11c7\u11c8\u0005n8\u0002\u11c8\u11d2\u0003\u0002\u0002", + "\u0002\u11c9\u11ca\u0007\u00c1\u0002\u0002\u11ca\u11cb\u0007\u00e4\u0002", + "\u0002\u11cb\u11cc\u0007o\u0002\u0002\u11cc\u11cd\u0007\u00de\u0002", + "\u0002\u11cd\u11ce\u0007\u0185\u0002\u0002\u11ce\u11cf\u0005\u020c\u0107", + "\u0002\u11cf\u11d0\u0005n8\u0002\u11d0\u11d2\u0003\u0002\u0002\u0002", + "\u11d1\u1183\u0003\u0002\u0002\u0002\u11d1\u118a\u0003\u0002\u0002\u0002", + "\u11d1\u118f\u0003\u0002\u0002\u0002\u11d1\u1196\u0003\u0002\u0002\u0002", + "\u11d1\u119b\u0003\u0002\u0002\u0002\u11d1\u11a2\u0003\u0002\u0002\u0002", + "\u11d1\u11ab\u0003\u0002\u0002\u0002\u11d1\u11b0\u0003\u0002\u0002\u0002", + "\u11d1\u11b7\u0003\u0002\u0002\u0002\u11d1\u11bc\u0003\u0002\u0002\u0002", + "\u11d1\u11c3\u0003\u0002\u0002\u0002\u11d1\u11c9\u0003\u0002\u0002\u0002", + "\u11d2\u0203\u0003\u0002\u0002\u0002\u11d3\u11eb\u0007^\u0002\u0002", + "\u11d4\u11eb\u0007\u0141\u0002\u0002\u11d5\u11eb\u0007\u0171\u0002\u0002", + "\u11d6\u11d7\u0007\u00fc\u0002\u0002\u11d7\u11eb\u0007\u0171\u0002\u0002", + "\u11d8\u11eb\u0007\u00e4\u0002\u0002\u11d9\u11da\u0007A\u0002\u0002", + "\u11da\u11eb\u0007^\u0002\u0002\u11db\u11eb\u0007n\u0002\u0002\u11dc", + "\u11eb\u0007\u00aa\u0002\u0002\u11dd\u11eb\u0007\u014f\u0002\u0002\u11de", + "\u11df\u0007\u015c\u0002\u0002\u11df\u11e0\u0007\u013e\u0002\u0002\u11e0", + "\u11eb\u0007\u0114\u0002\u0002\u11e1\u11e2\u0007\u015c\u0002\u0002\u11e2", + "\u11e3\u0007\u013e\u0002\u0002\u11e3\u11eb\u0007\u00bb\u0002\u0002\u11e4", + "\u11e5\u0007\u015c\u0002\u0002\u11e5\u11e6\u0007\u013e\u0002\u0002\u11e6", + "\u11eb\u0007\u015a\u0002\u0002\u11e7\u11e8\u0007\u015c\u0002\u0002\u11e8", + "\u11e9\u0007\u013e\u0002\u0002\u11e9\u11eb\u0007\u00a5\u0002\u0002\u11ea", + "\u11d3\u0003\u0002\u0002\u0002\u11ea\u11d4\u0003\u0002\u0002\u0002\u11ea", + "\u11d5\u0003\u0002\u0002\u0002\u11ea\u11d6\u0003\u0002\u0002\u0002\u11ea", + "\u11d8\u0003\u0002\u0002\u0002\u11ea\u11d9\u0003\u0002\u0002\u0002\u11ea", + "\u11db\u0003\u0002\u0002\u0002\u11ea\u11dc\u0003\u0002\u0002\u0002\u11ea", + "\u11dd\u0003\u0002\u0002\u0002\u11ea\u11de\u0003\u0002\u0002\u0002\u11ea", + "\u11e1\u0003\u0002\u0002\u0002\u11ea\u11e4\u0003\u0002\u0002\u0002\u11ea", + "\u11e7\u0003\u0002\u0002\u0002\u11eb\u0205\u0003\u0002\u0002\u0002\u11ec", + "\u11f2\u0005\u0208\u0105\u0002\u11ed\u11f2\u0007\u00b1\u0002\u0002\u11ee", + "\u11f2\u0007\u0137\u0002\u0002\u11ef\u11f2\u0007\u01bc\u0002\u0002\u11f0", + "\u11f2\u0007\u0158\u0002\u0002\u11f1\u11ec\u0003\u0002\u0002\u0002\u11f1", + "\u11ed\u0003\u0002\u0002\u0002\u11f1\u11ee\u0003\u0002\u0002\u0002\u11f1", + "\u11ef\u0003\u0002\u0002\u0002\u11f1\u11f0\u0003\u0002\u0002\u0002\u11f2", + "\u0207\u0003\u0002\u0002\u0002\u11f3\u11f4\u0007\u0085\u0002\u0002\u11f4", + "\u1202\u0007\u01b7\u0002\u0002\u11f5\u11f6\u0007\u00c8\u0002\u0002\u11f6", + "\u1202\u0007\u015e\u0002\u0002\u11f7\u1202\u0007\u00ce\u0002\u0002\u11f8", + "\u11f9\u0007A\u0002\u0002\u11f9\u11fa\u0007\u00b0\u0002\u0002\u11fa", + "\u1202\u0007\u0176\u0002\u0002\u11fb\u11fc\u0005\u0136\u009c\u0002\u11fc", + "\u11fd\u0007\u00f0\u0002\u0002\u11fd\u1202\u0003\u0002\u0002\u0002\u11fe", + "\u1202\u0007\u01bd\u0002\u0002\u11ff\u1202\u0007\u013c\u0002\u0002\u1200", + "\u1202\u0007\u0144\u0002\u0002\u1201\u11f3\u0003\u0002\u0002\u0002\u1201", + "\u11f5\u0003\u0002\u0002\u0002\u1201\u11f7\u0003\u0002\u0002\u0002\u1201", + "\u11f8\u0003\u0002\u0002\u0002\u1201\u11fb\u0003\u0002\u0002\u0002\u1201", + "\u11fe\u0003\u0002\u0002\u0002\u1201\u11ff\u0003\u0002\u0002\u0002\u1201", + "\u1200\u0003\u0002\u0002\u0002\u1202\u0209\u0003\u0002\u0002\u0002\u1203", + "\u1204\t\u0019\u0002\u0002\u1204\u020b\u0003\u0002\u0002\u0002\u1205", + "\u120a\u0005\u020e\u0108\u0002\u1206\u1207\u0007\b\u0002\u0002\u1207", + "\u1209\u0005\u020e\u0108\u0002\u1208\u1206\u0003\u0002\u0002\u0002\u1209", + "\u120c\u0003\u0002\u0002\u0002\u120a\u1208\u0003\u0002\u0002\u0002\u120a", + "\u120b\u0003\u0002\u0002\u0002\u120b\u020d\u0003\u0002\u0002\u0002\u120c", + "\u120a\u0003\u0002\u0002\u0002\u120d\u120f\u0005\u0552\u02aa\u0002\u120e", + "\u1210\u0005\u0210\u0109\u0002\u120f\u120e\u0003\u0002\u0002\u0002\u120f", + "\u1210\u0003\u0002\u0002\u0002\u1210\u020f\u0003\u0002\u0002\u0002\u1211", + "\u1212\u0007\r\u0002\u0002\u1212\u1214\u0005\u0534\u029b\u0002\u1213", + "\u1211\u0003\u0002\u0002\u0002\u1214\u1215\u0003\u0002\u0002\u0002\u1215", + "\u1213\u0003\u0002\u0002\u0002\u1215\u1216\u0003\u0002\u0002\u0002\u1216", + "\u0211\u0003\u0002\u0002\u0002\u1217\u121c\u0005\u0456\u022c\u0002\u1218", + "\u1219\u0007\b\u0002\u0002\u1219\u121b\u0005\u0456\u022c\u0002\u121a", + "\u1218\u0003\u0002\u0002\u0002\u121b\u121e\u0003\u0002\u0002\u0002\u121c", + "\u121a\u0003\u0002\u0002\u0002\u121c\u121d\u0003\u0002\u0002\u0002\u121d", + "\u0213\u0003\u0002\u0002\u0002\u121e\u121c\u0003\u0002\u0002\u0002\u121f", + "\u1220\u0007\u015f\u0002\u0002\u1220\u1221\u0005\u03d8\u01ed\u0002\u1221", + "\u1222\u0005\u042c\u0217\u0002\u1222\u1223\u0005\u0216\u010c\u0002\u1223", + "\u1224\u0005n8\u0002\u1224\u0215\u0003\u0002\u0002\u0002\u1225\u1226", + "\u0007\u00a9\u0002\u0002\u1226\u122b\u0007\u00dd\u0002\u0002\u1227\u1228", + "\u0007\u0133\u0002\u0002\u1228\u122b\u0007\u00dd\u0002\u0002\u1229\u122b", + "\u0003\u0002\u0002\u0002\u122a\u1225\u0003\u0002\u0002\u0002\u122a\u1227", + "\u0003\u0002\u0002\u0002\u122a\u1229\u0003\u0002\u0002\u0002\u122b\u0217", + "\u0003\u0002\u0002\u0002\u122c\u122d\u0007\u00a1\u0002\u0002\u122d\u122e", + "\u0007R\u0002\u0002\u122e\u122f\u0005\u0204\u0103\u0002\u122f\u1230", + "\u0005\u020e\u0108\u0002\u1230\u1231\u0007v\u0002\u0002\u1231\u1232", + "\u0005\u021a\u010e\u0002\u1232\u12c0\u0003\u0002\u0002\u0002\u1233\u1234", + "\u0007\u00a1\u0002\u0002\u1234\u1235\u0007R\u0002\u0002\u1235\u1236", + "\u0007.\u0002\u0002\u1236\u1237\u0005\u020e\u0108\u0002\u1237\u1238", + "\u0007v\u0002\u0002\u1238\u1239\u0005\u021a\u010e\u0002\u1239\u12c0", + "\u0003\u0002\u0002\u0002\u123a\u123b\u0007\u00a1\u0002\u0002\u123b\u123c", + "\u0007R\u0002\u0002\u123c\u123d\u0005\u0206\u0104\u0002\u123d\u123e", + "\u0005\u0532\u029a\u0002\u123e\u123f\u0007v\u0002\u0002\u123f\u1240", + "\u0005\u021a\u010e\u0002\u1240\u12c0\u0003\u0002\u0002\u0002\u1241\u1242", + "\u0007\u00a1\u0002\u0002\u1242\u1243\u0007R\u0002\u0002\u1243\u1244", + "\u0007\u0161\u0002\u0002\u1244\u1245\u0005\u0456\u022c\u0002\u1245\u1246", + "\u0007v\u0002\u0002\u1246\u1247\u0005\u021a\u010e\u0002\u1247\u12c0", + "\u0003\u0002\u0002\u0002\u1248\u1249\u0007\u00a1\u0002\u0002\u1249\u124a", + "\u0007R\u0002\u0002\u124a\u124b\u0007\u00bf\u0002\u0002\u124b\u124c", + "\u0005\u0456\u022c\u0002\u124c\u124d\u0007v\u0002\u0002\u124d\u124e", + "\u0005\u021a\u010e\u0002\u124e\u12c0\u0003\u0002\u0002\u0002\u124f\u1250", + "\u0007\u00a1\u0002\u0002\u1250\u1251\u0007R\u0002\u0002\u1251\u1252", + "\u0007\u008a\u0002\u0002\u1252\u1253\u0005\u028c\u0147\u0002\u1253\u1254", + "\u0007v\u0002\u0002\u1254\u1255\u0005\u021a\u010e\u0002\u1255\u12c0", + "\u0003\u0002\u0002\u0002\u1256\u1257\u0007\u00a1\u0002\u0002\u1257\u1258", + "\u0007R\u0002\u0002\u1258\u1259\u0007\u00d5\u0002\u0002\u1259\u125a", + "\u0005\u0274\u013b\u0002\u125a\u125b\u0007v\u0002\u0002\u125b\u125c", + "\u0005\u021a\u010e\u0002\u125c\u12c0\u0003\u0002\u0002\u0002\u125d\u125e", + "\u0007\u00a1\u0002\u0002\u125e\u125f\u0007R\u0002\u0002\u125f\u1260", + "\u0007\u010f\u0002\u0002\u1260\u1261\u0005\u02b2\u015a\u0002\u1261\u1262", + "\u0007v\u0002\u0002\u1262\u1263\u0005\u021a\u010e\u0002\u1263\u12c0", + "\u0003\u0002\u0002\u0002\u1264\u1265\u0007\u00a1\u0002\u0002\u1265\u1266", + "\u0007R\u0002\u0002\u1266\u1267\u0007/\u0002\u0002\u1267\u1268\u0005", + "\u0532\u029a\u0002\u1268\u1269\u0007R\u0002\u0002\u1269\u126a\u0005", + "\u020e\u0108\u0002\u126a\u126b\u0007v\u0002\u0002\u126b\u126c\u0005", + "\u021a\u010e\u0002\u126c\u12c0\u0003\u0002\u0002\u0002\u126d\u126e\u0007", + "\u00a1\u0002\u0002\u126e\u126f\u0007R\u0002\u0002\u126f\u1270\u0007", + "/\u0002\u0002\u1270\u1271\u0005\u0532\u029a\u0002\u1271\u1272\u0007", + "R\u0002\u0002\u1272\u1273\u0007\u00bf\u0002\u0002\u1273\u1274\u0005", + "\u020e\u0108\u0002\u1274\u1275\u0007v\u0002\u0002\u1275\u1276\u0005", + "\u021a\u010e\u0002\u1276\u12c0\u0003\u0002\u0002\u0002\u1277\u1278\u0007", + "\u00a1\u0002\u0002\u1278\u1279\u0007R\u0002\u0002\u1279\u127a\u0005", + "\u020a\u0106\u0002\u127a\u127b\u0005\u0532\u029a\u0002\u127b\u127c\u0007", + "R\u0002\u0002\u127c\u127d\u0005\u020e\u0108\u0002\u127d\u127e\u0007", + "v\u0002\u0002\u127e\u127f\u0005\u021a\u010e\u0002\u127f\u12c0\u0003", + "\u0002\u0002\u0002\u1280\u1281\u0007\u00a1\u0002\u0002\u1281\u1282\u0007", + "R\u0002\u0002\u1282\u1283\u0007\u0121\u0002\u0002\u1283\u1284\u0005", + "\u0274\u013b\u0002\u1284\u1285\u0007v\u0002\u0002\u1285\u1286\u0005", + "\u021a\u010e\u0002\u1286\u12c0\u0003\u0002\u0002\u0002\u1287\u1288\u0007", + "\u00a1\u0002\u0002\u1288\u1289\u0007R\u0002\u0002\u1289\u128a\u0007", + "\u01b3\u0002\u0002\u128a\u128b\u0005\u0274\u013b\u0002\u128b\u128c\u0007", + "v\u0002\u0002\u128c\u128d\u0005\u021a\u010e\u0002\u128d\u12c0\u0003", + "\u0002\u0002\u0002\u128e\u128f\u0007\u00a1\u0002\u0002\u128f\u1290\u0007", + "R\u0002\u0002\u1290\u1291\u0007\u01b4\u0002\u0002\u1291\u1292\u0007", + "@\u0002\u0002\u1292\u1293\u0005\u0456\u022c\u0002\u1293\u1294\u0007", + "\u00f0\u0002\u0002\u1294\u1295\u0005\u0532\u029a\u0002\u1295\u1296\u0007", + "v\u0002\u0002\u1296\u1297\u0005\u021a\u010e\u0002\u1297\u12c0\u0003", + "\u0002\u0002\u0002\u1298\u1299\u0007\u00a1\u0002\u0002\u1299\u129a\u0007", + "R\u0002\u0002\u129a\u129b\u0007\u010f\u0002\u0002\u129b\u129c\u0007", + "\u009e\u0002\u0002\u129c\u129d\u0005\u020e\u0108\u0002\u129d\u129e\u0007", + "f\u0002\u0002\u129e\u129f\u0005\u0532\u029a\u0002\u129f\u12a0\u0007", + "v\u0002\u0002\u12a0\u12a1\u0005\u021a\u010e\u0002\u12a1\u12c0\u0003", + "\u0002\u0002\u0002\u12a2\u12a3\u0007\u00a1\u0002\u0002\u12a3\u12a4\u0007", + "R\u0002\u0002\u12a4\u12a5\u0007\u010f\u0002\u0002\u12a5\u12a6\u0007", + "\u00d0\u0002\u0002\u12a6\u12a7\u0005\u020e\u0108\u0002\u12a7\u12a8\u0007", + "f\u0002\u0002\u12a8\u12a9\u0005\u0532\u029a\u0002\u12a9\u12aa\u0007", + "v\u0002\u0002\u12aa\u12ab\u0005\u021a\u010e\u0002\u12ab\u12c0\u0003", + "\u0002\u0002\u0002\u12ac\u12ad\u0007\u00a1\u0002\u0002\u12ad\u12ae\u0007", + "R\u0002\u0002\u12ae\u12af\u0007\u00f1\u0002\u0002\u12af\u12b0\u0007", + "\u010b\u0002\u0002\u12b0\u12b1\u0005\u0126\u0094\u0002\u12b1\u12b2\u0007", + "v\u0002\u0002\u12b2\u12b3\u0005\u021a\u010e\u0002\u12b3\u12c0\u0003", + "\u0002\u0002\u0002\u12b4\u12b5\u0007\u00a1\u0002\u0002\u12b5\u12b6\u0007", + "R\u0002\u0002\u12b6\u12b7\u0007+\u0002\u0002\u12b7\u12b8\u0007\u0004", + "\u0002\u0002\u12b8\u12b9\u0005\u0456\u022c\u0002\u12b9\u12ba\u0007&", + "\u0002\u0002\u12ba\u12bb\u0005\u0456\u022c\u0002\u12bb\u12bc\u0007\u0005", + "\u0002\u0002\u12bc\u12bd\u0007v\u0002\u0002\u12bd\u12be\u0005\u021a", + "\u010e\u0002\u12be\u12c0\u0003\u0002\u0002\u0002\u12bf\u122c\u0003\u0002", + "\u0002\u0002\u12bf\u1233\u0003\u0002\u0002\u0002\u12bf\u123a\u0003\u0002", + "\u0002\u0002\u12bf\u1241\u0003\u0002\u0002\u0002\u12bf\u1248\u0003\u0002", + "\u0002\u0002\u12bf\u124f\u0003\u0002\u0002\u0002\u12bf\u1256\u0003\u0002", + "\u0002\u0002\u12bf\u125d\u0003\u0002\u0002\u0002\u12bf\u1264\u0003\u0002", + "\u0002\u0002\u12bf\u126d\u0003\u0002\u0002\u0002\u12bf\u1277\u0003\u0002", + "\u0002\u0002\u12bf\u1280\u0003\u0002\u0002\u0002\u12bf\u1287\u0003\u0002", + "\u0002\u0002\u12bf\u128e\u0003\u0002\u0002\u0002\u12bf\u1298\u0003\u0002", + "\u0002\u0002\u12bf\u12a2\u0003\u0002\u0002\u0002\u12bf\u12ac\u0003\u0002", + "\u0002\u0002\u12bf\u12b4\u0003\u0002\u0002\u0002\u12c0\u0219\u0003\u0002", + "\u0002\u0002\u12c1\u12c4\u0005\u0544\u02a3\u0002\u12c2\u12c4\u0007P", + "\u0002\u0002\u12c3\u12c1\u0003\u0002\u0002\u0002\u12c3\u12c2\u0003\u0002", + "\u0002\u0002\u12c4\u021b\u0003\u0002\u0002\u0002\u12c5\u12c6\u0007\u0140", + "\u0002\u0002\u12c6\u12c7\u0007\u00ef\u0002\u0002\u12c7\u12c8\u0005\u021e", + "\u0110\u0002\u12c8\u12c9\u0007R\u0002\u0002\u12c9\u12ca\u0005\u0204", + "\u0103\u0002\u12ca\u12cb\u0005\u020e\u0108\u0002\u12cb\u12cc\u0007v", + "\u0002\u0002\u12cc\u12cd\u0005\u0220\u0111\u0002\u12cd\u1321\u0003\u0002", + "\u0002\u0002\u12ce\u12cf\u0007\u0140\u0002\u0002\u12cf\u12d0\u0007\u00ef", + "\u0002\u0002\u12d0\u12d1\u0005\u021e\u0110\u0002\u12d1\u12d2\u0007R", + "\u0002\u0002\u12d2\u12d3\u0007.\u0002\u0002\u12d3\u12d4\u0005\u020e", + "\u0108\u0002\u12d4\u12d5\u0007v\u0002\u0002\u12d5\u12d6\u0005\u0220", + "\u0111\u0002\u12d6\u1321\u0003\u0002\u0002\u0002\u12d7\u12d8\u0007\u0140", + "\u0002\u0002\u12d8\u12d9\u0007\u00ef\u0002\u0002\u12d9\u12da\u0005\u021e", + "\u0110\u0002\u12da\u12db\u0007R\u0002\u0002\u12db\u12dc\u0005\u0206", + "\u0104\u0002\u12dc\u12dd\u0005\u0532\u029a\u0002\u12dd\u12de\u0007v", + "\u0002\u0002\u12de\u12df\u0005\u0220\u0111\u0002\u12df\u1321\u0003\u0002", + "\u0002\u0002\u12e0\u12e1\u0007\u0140\u0002\u0002\u12e1\u12e2\u0007\u00ef", + "\u0002\u0002\u12e2\u12e3\u0005\u021e\u0110\u0002\u12e3\u12e4\u0007R", + "\u0002\u0002\u12e4\u12e5\u0007\u0161\u0002\u0002\u12e5\u12e6\u0005\u0456", + "\u022c\u0002\u12e6\u12e7\u0007v\u0002\u0002\u12e7\u12e8\u0005\u0220", + "\u0111\u0002\u12e8\u1321\u0003\u0002\u0002\u0002\u12e9\u12ea\u0007\u0140", + "\u0002\u0002\u12ea\u12eb\u0007\u00ef\u0002\u0002\u12eb\u12ec\u0005\u021e", + "\u0110\u0002\u12ec\u12ed\u0007R\u0002\u0002\u12ed\u12ee\u0007\u00bf", + "\u0002\u0002\u12ee\u12ef\u0005\u0456\u022c\u0002\u12ef\u12f0\u0007v", + "\u0002\u0002\u12f0\u12f1\u0005\u0220\u0111\u0002\u12f1\u1321\u0003\u0002", + "\u0002\u0002\u12f2\u12f3\u0007\u0140\u0002\u0002\u12f3\u12f4\u0007\u00ef", + "\u0002\u0002\u12f4\u12f5\u0005\u021e\u0110\u0002\u12f5\u12f6\u0007R", + "\u0002\u0002\u12f6\u12f7\u0007\u008a\u0002\u0002\u12f7\u12f8\u0005\u028c", + "\u0147\u0002\u12f8\u12f9\u0007v\u0002\u0002\u12f9\u12fa\u0005\u0220", + "\u0111\u0002\u12fa\u1321\u0003\u0002\u0002\u0002\u12fb\u12fc\u0007\u0140", + "\u0002\u0002\u12fc\u12fd\u0007\u00ef\u0002\u0002\u12fd\u12fe\u0005\u021e", + "\u0110\u0002\u12fe\u12ff\u0007R\u0002\u0002\u12ff\u1300\u0007\u00d5", + "\u0002\u0002\u1300\u1301\u0005\u0274\u013b\u0002\u1301\u1302\u0007v", + "\u0002\u0002\u1302\u1303\u0005\u0220\u0111\u0002\u1303\u1321\u0003\u0002", + "\u0002\u0002\u1304\u1305\u0007\u0140\u0002\u0002\u1305\u1306\u0007\u00ef", + "\u0002\u0002\u1306\u1307\u0005\u021e\u0110\u0002\u1307\u1308\u0007R", + "\u0002\u0002\u1308\u1309\u0007\u00f1\u0002\u0002\u1309\u130a\u0007\u010b", + "\u0002\u0002\u130a\u130b\u0005\u0126\u0094\u0002\u130b\u130c\u0007v", + "\u0002\u0002\u130c\u130d\u0005\u0220\u0111\u0002\u130d\u1321\u0003\u0002", + "\u0002\u0002\u130e\u130f\u0007\u0140\u0002\u0002\u130f\u1310\u0007\u00ef", + "\u0002\u0002\u1310\u1311\u0005\u021e\u0110\u0002\u1311\u1312\u0007R", + "\u0002\u0002\u1312\u1313\u0007\u0121\u0002\u0002\u1313\u1314\u0005\u0274", + "\u013b\u0002\u1314\u1315\u0007v\u0002\u0002\u1315\u1316\u0005\u0220", + "\u0111\u0002\u1316\u1321\u0003\u0002\u0002\u0002\u1317\u1318\u0007\u0140", + "\u0002\u0002\u1318\u1319\u0007\u00ef\u0002\u0002\u1319\u131a\u0005\u021e", + "\u0110\u0002\u131a\u131b\u0007R\u0002\u0002\u131b\u131c\u0007\u01b3", + "\u0002\u0002\u131c\u131d\u0005\u0274\u013b\u0002\u131d\u131e\u0007v", + "\u0002\u0002\u131e\u131f\u0005\u0220\u0111\u0002\u131f\u1321\u0003\u0002", + "\u0002\u0002\u1320\u12c5\u0003\u0002\u0002\u0002\u1320\u12ce\u0003\u0002", + "\u0002\u0002\u1320\u12d7\u0003\u0002\u0002\u0002\u1320\u12e0\u0003\u0002", + "\u0002\u0002\u1320\u12e9\u0003\u0002\u0002\u0002\u1320\u12f2\u0003\u0002", + "\u0002\u0002\u1320\u12fb\u0003\u0002\u0002\u0002\u1320\u1304\u0003\u0002", + "\u0002\u0002\u1320\u130e\u0003\u0002\u0002\u0002\u1320\u1317\u0003\u0002", + "\u0002\u0002\u1321\u021d\u0003\u0002\u0002\u0002\u1322\u1323\u0007@", + "\u0002\u0002\u1323\u1326\u0005J&\u0002\u1324\u1326\u0003\u0002\u0002", + "\u0002\u1325\u1322\u0003\u0002\u0002\u0002\u1325\u1324\u0003\u0002\u0002", + "\u0002\u1326\u021f\u0003\u0002\u0002\u0002\u1327\u132a\u0005\u0544\u02a3", + "\u0002\u1328\u132a\u0007P\u0002\u0002\u1329\u1327\u0003\u0002\u0002", + "\u0002\u1329\u1328\u0003\u0002\u0002\u0002\u132a\u0221\u0003\u0002\u0002", + "\u0002\u132b\u132c\u0007?\u0002\u0002\u132c\u1330\u0005\u0224\u0113", + "\u0002\u132d\u132e\u0007\u0102\u0002\u0002\u132e\u1330\u0005\u0224\u0113", + "\u0002\u132f\u132b\u0003\u0002\u0002\u0002\u132f\u132d\u0003\u0002\u0002", + "\u0002\u1330\u0223\u0003\u0002\u0002\u0002\u1331\u1374\u0005\u03b4\u01db", + "\u0002\u1332\u1333\u0005\u0226\u0114\u0002\u1333\u1334\u0005\u03b4\u01db", + "\u0002\u1334\u1374\u0003\u0002\u0002\u0002\u1335\u1336\u0007\u0105\u0002", + "\u0002\u1336\u1337\u0005\u0228\u0115\u0002\u1337\u1338\u0005\u03b4\u01db", + "\u0002\u1338\u1374\u0003\u0002\u0002\u0002\u1339\u133a\u0007\u011e\u0002", + "\u0002\u133a\u133b\u0005\u0228\u0115\u0002\u133b\u133c\u0005\u03b4\u01db", + "\u0002\u133c\u1374\u0003\u0002\u0002\u0002\u133d\u133e\u0007\u00d1\u0002", + "\u0002\u133e\u133f\u0005\u0228\u0115\u0002\u133f\u1340\u0005\u03b4\u01db", + "\u0002\u1340\u1374\u0003\u0002\u0002\u0002\u1341\u1342\u0007\u00f2\u0002", + "\u0002\u1342\u1343\u0005\u0228\u0115\u0002\u1343\u1344\u0005\u03b4\u01db", + "\u0002\u1344\u1374\u0003\u0002\u0002\u0002\u1345\u1346\u0007\u0084\u0002", + "\u0002\u1346\u1347\u0005\u054a\u02a6\u0002\u1347\u1348\u0005\u0228\u0115", + "\u0002\u1348\u1349\u0005\u03b4\u01db\u0002\u1349\u1374\u0003\u0002\u0002", + "\u0002\u134a\u134b\u0007\u012c\u0002\u0002\u134b\u134c\u0005\u054a\u02a6", + "\u0002\u134c\u134d\u0005\u0228\u0115\u0002\u134d\u134e\u0005\u03b4\u01db", + "\u0002\u134e\u1374\u0003\u0002\u0002\u0002\u134f\u1350\u0005\u054a\u02a6", + "\u0002\u1350\u1351\u0005\u0228\u0115\u0002\u1351\u1352\u0005\u03b4\u01db", + "\u0002\u1352\u1374\u0003\u0002\u0002\u0002\u1353\u1354\u0007 \u0002", + "\u0002\u1354\u1355\u0005\u0228\u0115\u0002\u1355\u1356\u0005\u03b4\u01db", + "\u0002\u1356\u1374\u0003\u0002\u0002\u0002\u1357\u1358\u0007\u00d4\u0002", + "\u0002\u1358\u1359\u0005\u0228\u0115\u0002\u1359\u135a\u0005\u03b4\u01db", + "\u0002\u135a\u1374\u0003\u0002\u0002\u0002\u135b\u135c\u0007\u00d4\u0002", + "\u0002\u135c\u135d\u0005\u054a\u02a6\u0002\u135d\u135e\u0005\u0228\u0115", + "\u0002\u135e\u135f\u0005\u03b4\u01db\u0002\u135f\u1374\u0003\u0002\u0002", + "\u0002\u1360\u1361\u0007\u00d4\u0002\u0002\u1361\u1362\u0007 \u0002", + "\u0002\u1362\u1363\u0005\u0228\u0115\u0002\u1363\u1364\u0005\u03b4\u01db", + "\u0002\u1364\u1374\u0003\u0002\u0002\u0002\u1365\u1366\u0007\u0092\u0002", + "\u0002\u1366\u1367\u0005\u0228\u0115\u0002\u1367\u1368\u0005\u03b4\u01db", + "\u0002\u1368\u1374\u0003\u0002\u0002\u0002\u1369\u136a\u0007\u0092\u0002", + "\u0002\u136a\u136b\u0005\u054a\u02a6\u0002\u136b\u136c\u0005\u0228\u0115", + "\u0002\u136c\u136d\u0005\u03b4\u01db\u0002\u136d\u1374\u0003\u0002\u0002", + "\u0002\u136e\u136f\u0007\u0092\u0002\u0002\u136f\u1370\u0007 \u0002", + "\u0002\u1370\u1371\u0005\u0228\u0115\u0002\u1371\u1372\u0005\u03b4\u01db", + "\u0002\u1372\u1374\u0003\u0002\u0002\u0002\u1373\u1331\u0003\u0002\u0002", + "\u0002\u1373\u1332\u0003\u0002\u0002\u0002\u1373\u1335\u0003\u0002\u0002", + "\u0002\u1373\u1339\u0003\u0002\u0002\u0002\u1373\u133d\u0003\u0002\u0002", + "\u0002\u1373\u1341\u0003\u0002\u0002\u0002\u1373\u1345\u0003\u0002\u0002", + "\u0002\u1373\u134a\u0003\u0002\u0002\u0002\u1373\u134f\u0003\u0002\u0002", + "\u0002\u1373\u1353\u0003\u0002\u0002\u0002\u1373\u1357\u0003\u0002\u0002", + "\u0002\u1373\u135b\u0003\u0002\u0002\u0002\u1373\u1360\u0003\u0002\u0002", + "\u0002\u1373\u1365\u0003\u0002\u0002\u0002\u1373\u1369\u0003\u0002\u0002", + "\u0002\u1373\u136e\u0003\u0002\u0002\u0002\u1374\u0225\u0003\u0002\u0002", + "\u0002\u1375\u1376\t\u001a\u0002\u0002\u1376\u0227\u0003\u0002\u0002", + "\u0002\u1377\u137a\u0005\u0226\u0114\u0002\u1378\u137a\u0003\u0002\u0002", + "\u0002\u1379\u1377\u0003\u0002\u0002\u0002\u1379\u1378\u0003\u0002\u0002", + "\u0002\u137a\u0229\u0003\u0002\u0002\u0002\u137b\u137c\u0007C\u0002", + "\u0002\u137c\u137d\u0005\u022e\u0118\u0002\u137d\u137e\u0007R\u0002", + "\u0002\u137e\u137f\u0005\u0234\u011b\u0002\u137f\u1380\u0007`\u0002", + "\u0002\u1380\u1381\u0005\u0236\u011c\u0002\u1381\u1382\u0005\u023a\u011e", + "\u0002\u1382\u022b\u0003\u0002\u0002\u0002\u1383\u1384\u0007\u0136\u0002", + "\u0002\u1384\u1385\u0005\u022e\u0118\u0002\u1385\u1386\u0007R\u0002", + "\u0002\u1386\u1387\u0005\u0234\u011b\u0002\u1387\u1388\u0007B\u0002", + "\u0002\u1388\u1389\u0005\u0236\u011c\u0002\u1389\u138a\u0005n8\u0002", + "\u138a\u1397\u0003\u0002\u0002\u0002\u138b\u138c\u0007\u0136\u0002\u0002", + "\u138c\u138d\u0007C\u0002\u0002\u138d\u138e\u0007\u0110\u0002\u0002", + "\u138e\u138f\u0007@\u0002\u0002\u138f\u1390\u0005\u022e\u0118\u0002", + "\u1390\u1391\u0007R\u0002\u0002\u1391\u1392\u0005\u0234\u011b\u0002", + "\u1392\u1393\u0007B\u0002\u0002\u1393\u1394\u0005\u0236\u011c\u0002", + "\u1394\u1395\u0005n8\u0002\u1395\u1397\u0003\u0002\u0002\u0002\u1396", + "\u1383\u0003\u0002\u0002\u0002\u1396\u138b\u0003\u0002\u0002\u0002\u1397", + "\u022d\u0003\u0002\u0002\u0002\u1398\u13a8\u0005\u0230\u0119\u0002\u1399", + "\u13a8\u0007 \u0002\u0002\u139a\u139b\u0007 \u0002\u0002\u139b\u13a8", + "\u0007\u011f\u0002\u0002\u139c\u139d\u0007 \u0002\u0002\u139d\u139e", + "\u0007\u0004\u0002\u0002\u139e\u139f\u0005\u00dan\u0002\u139f\u13a0", + "\u0007\u0005\u0002\u0002\u13a0\u13a8\u0003\u0002\u0002\u0002\u13a1\u13a2", + "\u0007 \u0002\u0002\u13a2\u13a3\u0007\u011f\u0002\u0002\u13a3\u13a4", + "\u0007\u0004\u0002\u0002\u13a4\u13a5\u0005\u00dan\u0002\u13a5\u13a6", + "\u0007\u0005\u0002\u0002\u13a6\u13a8\u0003\u0002\u0002\u0002\u13a7\u1398", + "\u0003\u0002\u0002\u0002\u13a7\u1399\u0003\u0002\u0002\u0002\u13a7\u139a", + "\u0003\u0002\u0002\u0002\u13a7\u139c\u0003\u0002\u0002\u0002\u13a7\u13a1", + "\u0003\u0002\u0002\u0002\u13a8\u022f\u0003\u0002\u0002\u0002\u13a9\u13ae", + "\u0005\u0232\u011a\u0002\u13aa\u13ab\u0007\b\u0002\u0002\u13ab\u13ad", + "\u0005\u0232\u011a\u0002\u13ac\u13aa\u0003\u0002\u0002\u0002\u13ad\u13b0", + "\u0003\u0002\u0002\u0002\u13ae\u13ac\u0003\u0002\u0002\u0002\u13ae\u13af", + "\u0003\u0002\u0002\u0002\u13af\u0231\u0003\u0002\u0002\u0002\u13b0\u13ae", + "\u0003\u0002\u0002\u0002\u13b1\u13b2\u0007Z\u0002\u0002\u13b2\u13bb", + "\u0005\u00d8m\u0002\u13b3\u13b4\u0007X\u0002\u0002\u13b4\u13bb\u0005", + "\u00d8m\u0002\u13b5\u13b6\u00070\u0002\u0002\u13b6\u13bb\u0005\u00d8", + "m\u0002\u13b7\u13b8\u0005\u0552\u02aa\u0002\u13b8\u13b9\u0005\u00d8", + "m\u0002\u13b9\u13bb\u0003\u0002\u0002\u0002\u13ba\u13b1\u0003\u0002", + "\u0002\u0002\u13ba\u13b3\u0003\u0002\u0002\u0002\u13ba\u13b5\u0003\u0002", + "\u0002\u0002\u13ba\u13b7\u0003\u0002\u0002\u0002\u13bb\u0233\u0003\u0002", + "\u0002\u0002\u13bc\u13f7\u0005\u052c\u0297\u0002\u13bd\u13be\u0007^", + "\u0002\u0002\u13be\u13f7\u0005\u052c\u0297\u0002\u13bf\u13c0\u0007\u0141", + "\u0002\u0002\u13c0\u13f7\u0005\u052c\u0297\u0002\u13c1\u13c2\u0007A", + "\u0002\u0002\u13c2\u13c3\u0007\u00b0\u0002\u0002\u13c3\u13c4\u0007\u0176", + "\u0002\u0002\u13c4\u13f7\u0005\u0530\u0299\u0002\u13c5\u13c6\u0007A", + "\u0002\u0002\u13c6\u13c7\u0007\u0144\u0002\u0002\u13c7\u13f7\u0005\u0530", + "\u0299\u0002\u13c8\u13c9\u0007\u00d5\u0002\u0002\u13c9\u13f7\u0005\u0272", + "\u013a\u0002\u13ca\u13cb\u0007\u0121\u0002\u0002\u13cb\u13f7\u0005\u0272", + "\u013a\u0002\u13cc\u13cd\u0007\u01b3\u0002\u0002\u13cd\u13f7\u0005\u0272", + "\u013a\u0002\u13ce\u13cf\u0007\u00b1\u0002\u0002\u13cf\u13f7\u0005\u0530", + "\u0299\u0002\u13d0\u13d1\u0007\u00bf\u0002\u0002\u13d1\u13f7\u0005\u020c", + "\u0107\u0002\u13d2\u13d3\u0007\u00f0\u0002\u0002\u13d3\u13f7\u0005\u0530", + "\u0299\u0002\u13d4\u13d5\u0007\u00f1\u0002\u0002\u13d5\u13d6\u0007\u010b", + "\u0002\u0002\u13d6\u13f7\u0005\u0128\u0095\u0002\u13d7\u13d8\u0007\u013c", + "\u0002\u0002\u13d8\u13f7\u0005\u0530\u0299\u0002\u13d9\u13da\u0007\u0158", + "\u0002\u0002\u13da\u13f7\u0005\u0530\u0299\u0002\u13db\u13dc\u0007\u0161", + "\u0002\u0002\u13dc\u13f7\u0005\u020c\u0107\u0002\u13dd\u13de\u0007 ", + "\u0002\u0002\u13de\u13df\u0007\u0157\u0002\u0002\u13df\u13e0\u0007F", + "\u0002\u0002\u13e0\u13e1\u0007\u013c\u0002\u0002\u13e1\u13f7\u0005\u0530", + "\u0299\u0002\u13e2\u13e3\u0007 \u0002\u0002\u13e3\u13e4\u0007\u0142", + "\u0002\u0002\u13e4\u13e5\u0007F\u0002\u0002\u13e5\u13e6\u0007\u013c", + "\u0002\u0002\u13e6\u13f7\u0005\u0530\u0299\u0002\u13e7\u13e8\u0007 ", + "\u0002\u0002\u13e8\u13e9\u0007\u00d6\u0002\u0002\u13e9\u13ea\u0007F", + "\u0002\u0002\u13ea\u13eb\u0007\u013c\u0002\u0002\u13eb\u13f7\u0005\u0530", + "\u0299\u0002\u13ec\u13ed\u0007 \u0002\u0002\u13ed\u13ee\u0007\u01c2", + "\u0002\u0002\u13ee\u13ef\u0007F\u0002\u0002\u13ef\u13f0\u0007\u013c", + "\u0002\u0002\u13f0\u13f7\u0005\u0530\u0299\u0002\u13f1\u13f2\u0007 ", + "\u0002\u0002\u13f2\u13f3\u0007\u01c0\u0002\u0002\u13f3\u13f4\u0007F", + "\u0002\u0002\u13f4\u13f5\u0007\u013c\u0002\u0002\u13f5\u13f7\u0005\u0530", + "\u0299\u0002\u13f6\u13bc\u0003\u0002\u0002\u0002\u13f6\u13bd\u0003\u0002", + "\u0002\u0002\u13f6\u13bf\u0003\u0002\u0002\u0002\u13f6\u13c1\u0003\u0002", + "\u0002\u0002\u13f6\u13c5\u0003\u0002\u0002\u0002\u13f6\u13c8\u0003\u0002", + "\u0002\u0002\u13f6\u13ca\u0003\u0002\u0002\u0002\u13f6\u13cc\u0003\u0002", + "\u0002\u0002\u13f6\u13ce\u0003\u0002\u0002\u0002\u13f6\u13d0\u0003\u0002", + "\u0002\u0002\u13f6\u13d2\u0003\u0002\u0002\u0002\u13f6\u13d4\u0003\u0002", + "\u0002\u0002\u13f6\u13d7\u0003\u0002\u0002\u0002\u13f6\u13d9\u0003\u0002", + "\u0002\u0002\u13f6\u13db\u0003\u0002\u0002\u0002\u13f6\u13dd\u0003\u0002", + "\u0002\u0002\u13f6\u13e2\u0003\u0002\u0002\u0002\u13f6\u13e7\u0003\u0002", + "\u0002\u0002\u13f6\u13ec\u0003\u0002\u0002\u0002\u13f6\u13f1\u0003\u0002", + "\u0002\u0002\u13f7\u0235\u0003\u0002\u0002\u0002\u13f8\u13fd\u0005\u0238", + "\u011d\u0002\u13f9\u13fa\u0007\b\u0002\u0002\u13fa\u13fc\u0005\u0238", + "\u011d\u0002\u13fb\u13f9\u0003\u0002\u0002\u0002\u13fc\u13ff\u0003\u0002", + "\u0002\u0002\u13fd\u13fb\u0003\u0002\u0002\u0002\u13fd\u13fe\u0003\u0002", + "\u0002\u0002\u13fe\u0237\u0003\u0002\u0002\u0002\u13ff\u13fd\u0003\u0002", + "\u0002\u0002\u1400\u1404\u0005\u054e\u02a8\u0002\u1401\u1402\u0007D", + "\u0002\u0002\u1402\u1404\u0005\u054e\u02a8\u0002\u1403\u1400\u0003\u0002", + "\u0002\u0002\u1403\u1401\u0003\u0002\u0002\u0002\u1404\u0239\u0003\u0002", + "\u0002\u0002\u1405\u1406\u0007k\u0002\u0002\u1406\u1407\u0007C\u0002", + "\u0002\u1407\u140a\u0007\u0110\u0002\u0002\u1408\u140a\u0003\u0002\u0002", + "\u0002\u1409\u1405\u0003\u0002\u0002\u0002\u1409\u1408\u0003\u0002\u0002", + "\u0002\u140a\u023b\u0003\u0002\u0002\u0002\u140b\u140c\u0007C\u0002", + "\u0002\u140c\u140d\u0005\u0230\u0119\u0002\u140d\u140e\u0007`\u0002", + "\u0002\u140e\u140f\u0005\u0550\u02a9\u0002\u140f\u1410\u0005\u0240\u0121", + "\u0002\u1410\u1411\u0005\u0242\u0122\u0002\u1411\u023d\u0003\u0002\u0002", + "\u0002\u1412\u1413\u0007\u0136\u0002\u0002\u1413\u1414\u0005\u0230\u0119", + "\u0002\u1414\u1415\u0007B\u0002\u0002\u1415\u1416\u0005\u0550\u02a9", + "\u0002\u1416\u1417\u0005\u0242\u0122\u0002\u1417\u1418\u0005n8\u0002", + "\u1418\u1424\u0003\u0002\u0002\u0002\u1419\u141a\u0007\u0136\u0002\u0002", + "\u141a\u141b\u0007\u0088\u0002\u0002\u141b\u141c\u0007\u0110\u0002\u0002", + "\u141c\u141d\u0007@\u0002\u0002\u141d\u141e\u0005\u0230\u0119\u0002", + "\u141e\u141f\u0007B\u0002\u0002\u141f\u1420\u0005\u0550\u02a9\u0002", + "\u1420\u1421\u0005\u0242\u0122\u0002\u1421\u1422\u0005n8\u0002\u1422", + "\u1424\u0003\u0002\u0002\u0002\u1423\u1412\u0003\u0002\u0002\u0002\u1423", + "\u1419\u0003\u0002\u0002\u0002\u1424\u023f\u0003\u0002\u0002\u0002\u1425", + "\u1426\u0007k\u0002\u0002\u1426\u1427\u0007\u0088\u0002\u0002\u1427", + "\u142a\u0007\u0110\u0002\u0002\u1428\u142a\u0003\u0002\u0002\u0002\u1429", + "\u1425\u0003\u0002\u0002\u0002\u1429\u1428\u0003\u0002\u0002\u0002\u142a", + "\u0241\u0003\u0002\u0002\u0002\u142b\u142c\u0007\u00d8\u0002\u0002\u142c", + "\u142d\u0007\u0095\u0002\u0002\u142d\u1430\u0005\u054e\u02a8\u0002\u142e", + "\u1430\u0003\u0002\u0002\u0002\u142f\u142b\u0003\u0002\u0002\u0002\u142f", + "\u142e\u0003\u0002\u0002\u0002\u1430\u0243\u0003\u0002\u0002\u0002\u1431", + "\u1432\u0007\u008c\u0002\u0002\u1432\u1433\u00077\u0002\u0002\u1433", + "\u1434\u0007\u011f\u0002\u0002\u1434\u1435\u0005\u0246\u0124\u0002\u1435", + "\u1436\u0005\u024a\u0126\u0002\u1436\u0245\u0003\u0002\u0002\u0002\u1437", + "\u1439\u0005\u0248\u0125\u0002\u1438\u1437\u0003\u0002\u0002\u0002\u1439", + "\u143c\u0003\u0002\u0002\u0002\u143a\u1438\u0003\u0002\u0002\u0002\u143a", + "\u143b\u0003\u0002\u0002\u0002\u143b\u0247\u0003\u0002\u0002\u0002\u143c", + "\u143a\u0003\u0002\u0002\u0002\u143d\u143e\u0007F\u0002\u0002\u143e", + "\u143f\u0007\u013c\u0002\u0002\u143f\u1447\u0005\u0530\u0299\u0002\u1440", + "\u1441\u0007@\u0002\u0002\u1441\u1442\u0007\u0137\u0002\u0002\u1442", + "\u1447\u0005\u0550\u02a9\u0002\u1443\u1444\u0007@\u0002\u0002\u1444", + "\u1445\u0007e\u0002\u0002\u1445\u1447\u0005\u0550\u02a9\u0002\u1446", + "\u143d\u0003\u0002\u0002\u0002\u1446\u1440\u0003\u0002\u0002\u0002\u1446", + "\u1443\u0003\u0002\u0002\u0002\u1447\u0249\u0003\u0002\u0002\u0002\u1448", + "\u1449\u0007C\u0002\u0002\u1449\u144a\u0005\u022e\u0118\u0002\u144a", + "\u144b\u0007R\u0002\u0002\u144b\u144c\u0005\u024c\u0127\u0002\u144c", + "\u144d\u0007`\u0002\u0002\u144d\u144e\u0005\u0236\u011c\u0002\u144e", + "\u144f\u0005\u023a\u011e\u0002\u144f\u1464\u0003\u0002\u0002\u0002\u1450", + "\u1451\u0007\u0136\u0002\u0002\u1451\u1452\u0005\u022e\u0118\u0002\u1452", + "\u1453\u0007R\u0002\u0002\u1453\u1454\u0005\u024c\u0127\u0002\u1454", + "\u1455\u0007B\u0002\u0002\u1455\u1456\u0005\u0236\u011c\u0002\u1456", + "\u1457\u0005n8\u0002\u1457\u1464\u0003\u0002\u0002\u0002\u1458\u1459", + "\u0007\u0136\u0002\u0002\u1459\u145a\u0007C\u0002\u0002\u145a\u145b", + "\u0007\u0110\u0002\u0002\u145b\u145c\u0007@\u0002\u0002\u145c\u145d", + "\u0005\u022e\u0118\u0002\u145d\u145e\u0007R\u0002\u0002\u145e\u145f", + "\u0005\u024c\u0127\u0002\u145f\u1460\u0007B\u0002\u0002\u1460\u1461", + "\u0005\u0236\u011c\u0002\u1461\u1462\u0005n8\u0002\u1462\u1464\u0003", + "\u0002\u0002\u0002\u1463\u1448\u0003\u0002\u0002\u0002\u1463\u1450\u0003", + "\u0002\u0002\u0002\u1463\u1458\u0003\u0002\u0002\u0002\u1464\u024b\u0003", + "\u0002\u0002\u0002\u1465\u1466\t\u001b\u0002\u0002\u1466\u024d\u0003", + "\u0002\u0002\u0002\u1467\u1468\u00070\u0002\u0002\u1468\u1469\u0005", + "\u0250\u0129\u0002\u1469\u146a\u0007\u00e4\u0002\u0002\u146a\u146b\u0005", + "\u0252\u012a\u0002\u146b\u146c\u0005\u0254\u012b\u0002\u146c\u146d\u0007", + "R\u0002\u0002\u146d\u146e\u0005\u042a\u0216\u0002\u146e\u146f\u0005", + "\u0256\u012c\u0002\u146f\u1470\u0007\u0004\u0002\u0002\u1470\u1471\u0005", + "\u0258\u012d\u0002\u1471\u1472\u0007\u0005\u0002\u0002\u1472\u1473\u0005", + "\u025e\u0130\u0002\u1473\u1474\u0005x=\u0002\u1474\u1475\u0005\u0100", + "\u0081\u0002\u1475\u1476\u0005\u043e\u0220\u0002\u1476\u148b\u0003\u0002", + "\u0002\u0002\u1477\u1478\u00070\u0002\u0002\u1478\u1479\u0005\u0250", + "\u0129\u0002\u1479\u147a\u0007\u00e4\u0002\u0002\u147a\u147b\u0005\u0252", + "\u012a\u0002\u147b\u147c\u0007\u00de\u0002\u0002\u147c\u147d\u0007O", + "\u0002\u0002\u147d\u147e\u0007\u0185\u0002\u0002\u147e\u147f\u0005\u0532", + "\u029a\u0002\u147f\u1480\u0007R\u0002\u0002\u1480\u1481\u0005\u042a", + "\u0216\u0002\u1481\u1482\u0005\u0256\u012c\u0002\u1482\u1483\u0007\u0004", + "\u0002\u0002\u1483\u1484\u0005\u0258\u012d\u0002\u1484\u1485\u0007\u0005", + "\u0002\u0002\u1485\u1486\u0005\u025e\u0130\u0002\u1486\u1487\u0005x", + "=\u0002\u1487\u1488\u0005\u0100\u0081\u0002\u1488\u1489\u0005\u043e", + "\u0220\u0002\u1489\u148b\u0003\u0002\u0002\u0002\u148a\u1467\u0003\u0002", + "\u0002\u0002\u148a\u1477\u0003\u0002\u0002\u0002\u148b\u024f\u0003\u0002", + "\u0002\u0002\u148c\u148f\u0007d\u0002\u0002\u148d\u148f\u0003\u0002", + "\u0002\u0002\u148e\u148c\u0003\u0002\u0002\u0002\u148e\u148d\u0003\u0002", + "\u0002\u0002\u148f\u0251\u0003\u0002\u0002\u0002\u1490\u1493\u0007o", + "\u0002\u0002\u1491\u1493\u0003\u0002\u0002\u0002\u1492\u1490\u0003\u0002", + "\u0002\u0002\u1492\u1491\u0003\u0002\u0002\u0002\u1493\u0253\u0003\u0002", + "\u0002\u0002\u1494\u1497\u0005\u0532\u029a\u0002\u1495\u1497\u0003\u0002", + "\u0002\u0002\u1496\u1494\u0003\u0002\u0002\u0002\u1496\u1495\u0003\u0002", + "\u0002\u0002\u1497\u0255\u0003\u0002\u0002\u0002\u1498\u1499\u0007f", + "\u0002\u0002\u1499\u149c\u0005\u0532\u029a\u0002\u149a\u149c\u0003\u0002", + "\u0002\u0002\u149b\u1498\u0003\u0002\u0002\u0002\u149b\u149a\u0003\u0002", + "\u0002\u0002\u149c\u0257\u0003\u0002\u0002\u0002\u149d\u14a2\u0005\u025c", + "\u012f\u0002\u149e\u149f\u0007\b\u0002\u0002\u149f\u14a1\u0005\u025c", + "\u012f\u0002\u14a0\u149e\u0003\u0002\u0002\u0002\u14a1\u14a4\u0003\u0002", + "\u0002\u0002\u14a2\u14a0\u0003\u0002\u0002\u0002\u14a2\u14a3\u0003\u0002", + "\u0002\u0002\u14a3\u0259\u0003\u0002\u0002\u0002\u14a4\u14a2\u0003\u0002", + "\u0002\u0002\u14a5\u14a6\u0005\u0262\u0132\u0002\u14a6\u14a7\u0005\u0264", + "\u0133\u0002\u14a7\u14a8\u0005\u0266\u0134\u0002\u14a8\u14a9\u0005\u0268", + "\u0135\u0002\u14a9\u14b1\u0003\u0002\u0002\u0002\u14aa\u14ab\u0005\u0262", + "\u0132\u0002\u14ab\u14ac\u0005\u020e\u0108\u0002\u14ac\u14ad\u0005v", + "<\u0002\u14ad\u14ae\u0005\u0266\u0134\u0002\u14ae\u14af\u0005\u0268", + "\u0135\u0002\u14af\u14b1\u0003\u0002\u0002\u0002\u14b0\u14a5\u0003\u0002", + "\u0002\u0002\u14b0\u14aa\u0003\u0002\u0002\u0002\u14b1\u025b\u0003\u0002", + "\u0002\u0002\u14b2\u14b3\u0005\u0552\u02aa\u0002\u14b3\u14b4\u0005\u025a", + "\u012e\u0002\u14b4\u14be\u0003\u0002\u0002\u0002\u14b5\u14b6\u0005\u04b4", + "\u025b\u0002\u14b6\u14b7\u0005\u025a\u012e\u0002\u14b7\u14be\u0003\u0002", + "\u0002\u0002\u14b8\u14b9\u0007\u0004\u0002\u0002\u14b9\u14ba\u0005\u0482", + "\u0242\u0002\u14ba\u14bb\u0007\u0005\u0002\u0002\u14bb\u14bc\u0005\u025a", + "\u012e\u0002\u14bc\u14be\u0003\u0002\u0002\u0002\u14bd\u14b2\u0003\u0002", + "\u0002\u0002\u14bd\u14b5\u0003\u0002\u0002\u0002\u14bd\u14b8\u0003\u0002", + "\u0002\u0002\u14be\u025d\u0003\u0002\u0002\u0002\u14bf\u14c0\u0007\u01b2", + "\u0002\u0002\u14c0\u14c1\u0007\u0004\u0002\u0002\u14c1\u14c2\u0005\u0260", + "\u0131\u0002\u14c2\u14c3\u0007\u0005\u0002\u0002\u14c3\u14c6\u0003\u0002", + "\u0002\u0002\u14c4\u14c6\u0003\u0002\u0002\u0002\u14c5\u14bf\u0003\u0002", + "\u0002\u0002\u14c5\u14c4\u0003\u0002\u0002\u0002\u14c6\u025f\u0003\u0002", + "\u0002\u0002\u14c7\u14cc\u0005\u025c\u012f\u0002\u14c8\u14c9\u0007\b", + "\u0002\u0002\u14c9\u14cb\u0005\u025c\u012f\u0002\u14ca\u14c8\u0003\u0002", + "\u0002\u0002\u14cb\u14ce\u0003\u0002\u0002\u0002\u14cc\u14ca\u0003\u0002", + "\u0002\u0002\u14cc\u14cd\u0003\u0002\u0002\u0002\u14cd\u0261\u0003\u0002", + "\u0002\u0002\u14ce\u14cc\u0003\u0002\u0002\u0002\u14cf\u14d0\u0007-", + "\u0002\u0002\u14d0\u14d3\u0005\u020e\u0108\u0002\u14d1\u14d3\u0003\u0002", + "\u0002\u0002\u14d2\u14cf\u0003\u0002\u0002\u0002\u14d2\u14d1\u0003\u0002", + "\u0002\u0002\u14d3\u0263\u0003\u0002\u0002\u0002\u14d4\u14d7\u0005\u020e", + "\u0108\u0002\u14d5\u14d7\u0003\u0002\u0002\u0002\u14d6\u14d4\u0003\u0002", + "\u0002\u0002\u14d6\u14d5\u0003\u0002\u0002\u0002\u14d7\u0265\u0003\u0002", + "\u0002\u0002\u14d8\u14dc\u0007\'\u0002\u0002\u14d9\u14dc\u00079\u0002", + "\u0002\u14da\u14dc\u0003\u0002\u0002\u0002\u14db\u14d8\u0003\u0002\u0002", + "\u0002\u14db\u14d9\u0003\u0002\u0002\u0002\u14db\u14da\u0003\u0002\u0002", + "\u0002\u14dc\u0267\u0003\u0002\u0002\u0002\u14dd\u14de\u0007\u010a\u0002", + "\u0002\u14de\u14e3\u0007\u00d1\u0002\u0002\u14df\u14e0\u0007\u010a\u0002", + "\u0002\u14e0\u14e3\u0007\u00f2\u0002\u0002\u14e1\u14e3\u0003\u0002\u0002", + "\u0002\u14e2\u14dd\u0003\u0002\u0002\u0002\u14e2\u14df\u0003\u0002\u0002", + "\u0002\u14e2\u14e1\u0003\u0002\u0002\u0002\u14e3\u0269\u0003\u0002\u0002", + "\u0002\u14e4\u14e5\u00070\u0002\u0002\u14e5\u14e6\u0005\u026c\u0137", + "\u0002\u14e6\u14e7\t\u0018\u0002\u0002\u14e7\u14e8\u0005\u0538\u029d", + "\u0002\u14e8\u14f2\u0005\u0276\u013c\u0002\u14e9\u14f0\u0007\u0135\u0002", + "\u0002\u14ea\u14f1\u0005\u0280\u0141\u0002\u14eb\u14ec\u0007^\u0002", + "\u0002\u14ec\u14ed\u0007\u0004\u0002\u0002\u14ed\u14ee\u0005\u029e\u0150", + "\u0002\u14ee\u14ef\u0007\u0005\u0002\u0002\u14ef\u14f1\u0003\u0002\u0002", + "\u0002\u14f0\u14ea\u0003\u0002\u0002\u0002\u14f0\u14eb\u0003\u0002\u0002", + "\u0002\u14f1\u14f3\u0003\u0002\u0002\u0002\u14f2\u14e9\u0003\u0002\u0002", + "\u0002\u14f2\u14f3\u0003\u0002\u0002\u0002\u14f3\u14f4\u0003\u0002\u0002", + "\u0002\u14f4\u14f5\u0005\u0290\u0149\u0002\u14f5\u026b\u0003\u0002\u0002", + "\u0002\u14f6\u14f7\u0007T\u0002\u0002\u14f7\u14fa\u0007\u0130\u0002", + "\u0002\u14f8\u14fa\u0003\u0002\u0002\u0002\u14f9\u14f6\u0003\u0002\u0002", + "\u0002\u14f9\u14f8\u0003\u0002\u0002\u0002\u14fa\u026d\u0003\u0002\u0002", + "\u0002\u14fb\u14fd\u0007\u0004\u0002\u0002\u14fc\u14fe\u0005\u0270\u0139", + "\u0002\u14fd\u14fc\u0003\u0002\u0002\u0002\u14fd\u14fe\u0003\u0002\u0002", + "\u0002\u14fe\u14ff\u0003\u0002\u0002\u0002\u14ff\u1500\u0007\u0005\u0002", + "\u0002\u1500\u026f\u0003\u0002\u0002\u0002\u1501\u1506\u0005\u027a\u013e", + "\u0002\u1502\u1503\u0007\b\u0002\u0002\u1503\u1505\u0005\u027a\u013e", + "\u0002\u1504\u1502\u0003\u0002\u0002\u0002\u1505\u1508\u0003\u0002\u0002", + "\u0002\u1506\u1504\u0003\u0002\u0002\u0002\u1506\u1507\u0003\u0002\u0002", + "\u0002\u1507\u0271\u0003\u0002\u0002\u0002\u1508\u1506\u0003\u0002\u0002", + "\u0002\u1509\u150e\u0005\u0274\u013b\u0002\u150a\u150b\u0007\b\u0002", + "\u0002\u150b\u150d\u0005\u0274\u013b\u0002\u150c\u150a\u0003\u0002\u0002", + "\u0002\u150d\u1510\u0003\u0002\u0002\u0002\u150e\u150c\u0003\u0002\u0002", + "\u0002\u150e\u150f\u0003\u0002\u0002\u0002\u150f\u0273\u0003\u0002\u0002", + "\u0002\u1510\u150e\u0003\u0002\u0002\u0002\u1511\u1512\u0005\u0538\u029d", + "\u0002\u1512\u1513\u0005\u026e\u0138\u0002\u1513\u151a\u0003\u0002\u0002", + "\u0002\u1514\u151a\u0005\u0562\u02b2\u0002\u1515\u1517\u0005\u0552\u02aa", + "\u0002\u1516\u1518\u0005\u0522\u0292\u0002\u1517\u1516\u0003\u0002\u0002", + "\u0002\u1517\u1518\u0003\u0002\u0002\u0002\u1518\u151a\u0003\u0002\u0002", + "\u0002\u1519\u1511\u0003\u0002\u0002\u0002\u1519\u1514\u0003\u0002\u0002", + "\u0002\u1519\u1515\u0003\u0002\u0002\u0002\u151a\u0275\u0003\u0002\u0002", + "\u0002\u151b\u151d\u0007\u0004\u0002\u0002\u151c\u151e\u0005\u0278\u013d", + "\u0002\u151d\u151c\u0003\u0002\u0002\u0002\u151d\u151e\u0003\u0002\u0002", + "\u0002\u151e\u151f\u0003\u0002\u0002\u0002\u151f\u1520\u0007\u0005\u0002", + "\u0002\u1520\u0277\u0003\u0002\u0002\u0002\u1521\u1526\u0005\u0284\u0143", + "\u0002\u1522\u1523\u0007\b\u0002\u0002\u1523\u1525\u0005\u0284\u0143", + "\u0002\u1524\u1522\u0003\u0002\u0002\u0002\u1525\u1528\u0003\u0002\u0002", + "\u0002\u1526\u1524\u0003\u0002\u0002\u0002\u1526\u1527\u0003\u0002\u0002", + "\u0002\u1527\u0279\u0003\u0002\u0002\u0002\u1528\u1526\u0003\u0002\u0002", + "\u0002\u1529\u152b\u0005\u027c\u013f\u0002\u152a\u152c\u0005\u027e\u0140", + "\u0002\u152b\u152a\u0003\u0002\u0002\u0002\u152b\u152c\u0003\u0002\u0002", + "\u0002\u152c\u152d\u0003\u0002\u0002\u0002\u152d\u152e\u0005\u0282\u0142", + "\u0002\u152e\u1537\u0003\u0002\u0002\u0002\u152f\u1531\u0005\u027e\u0140", + "\u0002\u1530\u1532\u0005\u027c\u013f\u0002\u1531\u1530\u0003\u0002\u0002", + "\u0002\u1531\u1532\u0003\u0002\u0002\u0002\u1532\u1533\u0003\u0002\u0002", + "\u0002\u1533\u1534\u0005\u0282\u0142\u0002\u1534\u1537\u0003\u0002\u0002", + "\u0002\u1535\u1537\u0005\u0282\u0142\u0002\u1536\u1529\u0003\u0002\u0002", + "\u0002\u1536\u152f\u0003\u0002\u0002\u0002\u1536\u1535\u0003\u0002\u0002", + "\u0002\u1537\u027b\u0003\u0002\u0002\u0002\u1538\u153a\u0007F\u0002", + "\u0002\u1539\u153b\u0007\u01be\u0002\u0002\u153a\u1539\u0003\u0002\u0002", + "\u0002\u153a\u153b\u0003\u0002\u0002\u0002\u153b\u1540\u0003\u0002\u0002", + "\u0002\u153c\u1540\u0007\u01be\u0002\u0002\u153d\u1540\u0007\u0189\u0002", + "\u0002\u153e\u1540\u0007g\u0002\u0002\u153f\u1538\u0003\u0002\u0002", + "\u0002\u153f\u153c\u0003\u0002\u0002\u0002\u153f\u153d\u0003\u0002\u0002", + "\u0002\u153f\u153e\u0003\u0002\u0002\u0002\u1540\u027d\u0003\u0002\u0002", + "\u0002\u1541\u1542\u0005\u0554\u02ab\u0002\u1542\u027f\u0003\u0002\u0002", + "\u0002\u1543\u1544\u0005\u0282\u0142\u0002\u1544\u0281\u0003\u0002\u0002", + "\u0002\u1545\u1552\u0005\u0456\u022c\u0002\u1546\u1547\u0005\u0554\u02ab", + "\u0002\u1547\u1548\u0005\u0210\u0109\u0002\u1548\u1549\u0007\u001d\u0002", + "\u0002\u1549\u154a\u0007\u0161\u0002\u0002\u154a\u1552\u0003\u0002\u0002", + "\u0002\u154b\u154c\u0007\u0198\u0002\u0002\u154c\u154d\u0005\u0554\u02ab", + "\u0002\u154d\u154e\u0005\u0210\u0109\u0002\u154e\u154f\u0007\u001d\u0002", + "\u0002\u154f\u1550\u0007\u0161\u0002\u0002\u1550\u1552\u0003\u0002\u0002", + "\u0002\u1551\u1545\u0003\u0002\u0002\u0002\u1551\u1546\u0003\u0002\u0002", + "\u0002\u1551\u154b\u0003\u0002\u0002\u0002\u1552\u0283\u0003\u0002\u0002", + "\u0002\u1553\u1556\u0005\u027a\u013e\u0002\u1554\u1555\t\u001c\u0002", + "\u0002\u1555\u1557\u0005\u0482\u0242\u0002\u1556\u1554\u0003\u0002\u0002", + "\u0002\u1556\u1557\u0003\u0002\u0002\u0002\u1557\u0285\u0003\u0002\u0002", + "\u0002\u1558\u1559\u0005\u027a\u013e\u0002\u1559\u0287\u0003\u0002\u0002", + "\u0002\u155a\u1565\u0007\u0004\u0002\u0002\u155b\u1566\u0007\u000b\u0002", + "\u0002\u155c\u1566\u0005\u028a\u0146\u0002\u155d\u155e\u0007U\u0002", + "\u0002\u155e\u155f\u0007\u0095\u0002\u0002\u155f\u1566\u0005\u028a\u0146", + "\u0002\u1560\u1561\u0005\u028a\u0146\u0002\u1561\u1562\u0007U\u0002", + "\u0002\u1562\u1563\u0007\u0095\u0002\u0002\u1563\u1564\u0005\u028a\u0146", + "\u0002\u1564\u1566\u0003\u0002\u0002\u0002\u1565\u155b\u0003\u0002\u0002", + "\u0002\u1565\u155c\u0003\u0002\u0002\u0002\u1565\u155d\u0003\u0002\u0002", + "\u0002\u1565\u1560\u0003\u0002\u0002\u0002\u1566\u1567\u0003\u0002\u0002", + "\u0002\u1567\u1568\u0007\u0005\u0002\u0002\u1568\u0289\u0003\u0002\u0002", + "\u0002\u1569\u156e\u0005\u0286\u0144\u0002\u156a\u156b\u0007\b\u0002", + "\u0002\u156b\u156d\u0005\u0286\u0144\u0002\u156c\u156a\u0003\u0002\u0002", + "\u0002\u156d\u1570\u0003\u0002\u0002\u0002\u156e\u156c\u0003\u0002\u0002", + "\u0002\u156e\u156f\u0003\u0002\u0002\u0002\u156f\u028b\u0003\u0002\u0002", + "\u0002\u1570\u156e\u0003\u0002\u0002\u0002\u1571\u1572\u0005\u0538\u029d", + "\u0002\u1572\u1573\u0005\u0288\u0145\u0002\u1573\u028d\u0003\u0002\u0002", + "\u0002\u1574\u1579\u0005\u028c\u0147\u0002\u1575\u1576\u0007\b\u0002", + "\u0002\u1576\u1578\u0005\u028c\u0147\u0002\u1577\u1575\u0003\u0002\u0002", + "\u0002\u1578\u157b\u0003\u0002\u0002\u0002\u1579\u1577\u0003\u0002\u0002", + "\u0002\u1579\u157a\u0003\u0002\u0002\u0002\u157a\u028f\u0003\u0002\u0002", + "\u0002\u157b\u1579\u0003\u0002\u0002\u0002\u157c\u157e\u0005\u0294\u014b", + "\u0002\u157d\u157c\u0003\u0002\u0002\u0002\u157e\u157f\u0003\u0002\u0002", + "\u0002\u157f\u157d\u0003\u0002\u0002\u0002\u157f\u1580\u0003\u0002\u0002", + "\u0002\u1580\u1581\u0003\u0002\u0002\u0002\u1581\u1582\b\u0149\u0001", + "\u0002\u1582\u0291\u0003\u0002\u0002\u0002\u1583\u1584\u0007\u0097\u0002", + "\u0002\u1584\u1585\u0007R\u0002\u0002\u1585\u1586\u0007P\u0002\u0002", + "\u1586\u15a7\u0007\u01c3\u0002\u0002\u1587\u1588\u0007\u0135\u0002\u0002", + "\u1588\u1589\u0007P\u0002\u0002\u1589\u158a\u0007R\u0002\u0002\u158a", + "\u158b\u0007P\u0002\u0002\u158b\u15a7\u0007\u01c3\u0002\u0002\u158c", + "\u15a7\u0007\u0153\u0002\u0002\u158d\u15a7\u0007\u00e0\u0002\u0002\u158e", + "\u15a7\u0007\u014b\u0002\u0002\u158f\u15a7\u0007\u0172\u0002\u0002\u1590", + "\u1591\u0007\u00cf\u0002\u0002\u1591\u1592\u0007\u0140\u0002\u0002\u1592", + "\u15a7\u0007\u00b7\u0002\u0002\u1593\u1594\u0007\u00cf\u0002\u0002\u1594", + "\u1595\u0007\u0140\u0002\u0002\u1595\u15a7\u0007\u00ec\u0002\u0002\u1596", + "\u1597\u0007\u0140\u0002\u0002\u1597\u15a7\u0007\u00b7\u0002\u0002\u1598", + "\u1599\u0007\u0140\u0002\u0002\u1599\u15a7\u0007\u00ec\u0002\u0002\u159a", + "\u15a7\u0007\u00f3\u0002\u0002\u159b\u159c\u0007O\u0002\u0002\u159c", + "\u15a7\u0007\u00f3\u0002\u0002\u159d\u159e\u0007\u00ac\u0002\u0002\u159e", + "\u15a7\u0005\u0126\u0094\u0002\u159f\u15a0\u0007\u0139\u0002\u0002\u15a0", + "\u15a7\u0005\u0126\u0094\u0002\u15a1\u15a2\u0007\u01c4\u0002\u0002\u15a2", + "\u15a7\u0005\u020e\u0108\u0002\u15a3\u15a7\u0005T+\u0002\u15a4\u15a5", + "\u0007\u01c5\u0002\u0002\u15a5\u15a7\u0005\u0552\u02aa\u0002\u15a6\u1583", + "\u0003\u0002\u0002\u0002\u15a6\u1587\u0003\u0002\u0002\u0002\u15a6\u158c", + "\u0003\u0002\u0002\u0002\u15a6\u158d\u0003\u0002\u0002\u0002\u15a6\u158e", + "\u0003\u0002\u0002\u0002\u15a6\u158f\u0003\u0002\u0002\u0002\u15a6\u1590", + "\u0003\u0002\u0002\u0002\u15a6\u1593\u0003\u0002\u0002\u0002\u15a6\u1596", + "\u0003\u0002\u0002\u0002\u15a6\u1598\u0003\u0002\u0002\u0002\u15a6\u159a", + "\u0003\u0002\u0002\u0002\u15a6\u159b\u0003\u0002\u0002\u0002\u15a6\u159d", + "\u0003\u0002\u0002\u0002\u15a6\u159f\u0003\u0002\u0002\u0002\u15a6\u15a1", + "\u0003\u0002\u0002\u0002\u15a6\u15a3\u0003\u0002\u0002\u0002\u15a6\u15a4", + "\u0003\u0002\u0002\u0002\u15a7\u0293\u0003\u0002\u0002\u0002\u15a8\u15a9", + "\u0007&\u0002\u0002\u15a9\u15b1\u0005\u0296\u014c\u0002\u15aa\u15ab", + "\u0007\u00f0\u0002\u0002\u15ab\u15b1\u0005J&\u0002\u15ac\u15ad\u0007", + "\u01b4\u0002\u0002\u15ad\u15b1\u0005\u0298\u014d\u0002\u15ae\u15b1\u0007", + "j\u0002\u0002\u15af\u15b1\u0005\u0292\u014a\u0002\u15b0\u15a8\u0003", + "\u0002\u0002\u0002\u15b0\u15aa\u0003\u0002\u0002\u0002\u15b0\u15ac\u0003", + "\u0002\u0002\u0002\u15b0\u15ae\u0003\u0002\u0002\u0002\u15b0\u15af\u0003", + "\u0002\u0002\u0002\u15b1\u0295\u0003\u0002\u0002\u0002\u15b2\u15b8\u0005", + "\u0544\u02a3\u0002\u15b3\u15b4\u0005\u0544\u02a3\u0002\u15b4\u15b5\u0007", + "\b\u0002\u0002\u15b5\u15b6\u0005\u0544\u02a3\u0002\u15b6\u15b8\u0003", + "\u0002\u0002\u0002\u15b7\u15b2\u0003\u0002\u0002\u0002\u15b7\u15b3\u0003", + "\u0002\u0002\u0002\u15b8\u0297\u0003\u0002\u0002\u0002\u15b9\u15ba\u0007", + "@\u0002\u0002\u15ba\u15bb\u0007\u0161\u0002\u0002\u15bb\u15c2\u0005", + "\u0456\u022c\u0002\u15bc\u15bd\u0007\b\u0002\u0002\u15bd\u15be\u0007", + "@\u0002\u0002\u15be\u15bf\u0007\u0161\u0002\u0002\u15bf\u15c1\u0005", + "\u0456\u022c\u0002\u15c0\u15bc\u0003\u0002\u0002\u0002\u15c1\u15c4\u0003", + "\u0002\u0002\u0002\u15c2\u15c0\u0003\u0002\u0002\u0002\u15c2\u15c3\u0003", + "\u0002\u0002\u0002\u15c3\u0299\u0003\u0002\u0002\u0002\u15c4\u15c2\u0003", + "\u0002\u0002\u0002\u15c5\u15c6\u0007k\u0002\u0002\u15c6\u15c9\u0005", + "\u01ce\u00e8\u0002\u15c7\u15c9\u0003\u0002\u0002\u0002\u15c8\u15c5\u0003", + "\u0002\u0002\u0002\u15c8\u15c7\u0003\u0002\u0002\u0002\u15c9\u029b\u0003", + "\u0002\u0002\u0002\u15ca\u15cb\u0005\u027e\u0140\u0002\u15cb\u15cc\u0005", + "\u0282\u0142\u0002\u15cc\u029d\u0003\u0002\u0002\u0002\u15cd\u15d2\u0005", + "\u029c\u014f\u0002\u15ce\u15cf\u0007\b\u0002\u0002\u15cf\u15d1\u0005", + "\u029c\u014f\u0002\u15d0\u15ce\u0003\u0002\u0002\u0002\u15d1\u15d4\u0003", + "\u0002\u0002\u0002\u15d2\u15d0\u0003\u0002\u0002\u0002\u15d2\u15d3\u0003", + "\u0002\u0002\u0002\u15d3\u029f\u0003\u0002\u0002\u0002\u15d4\u15d2\u0003", + "\u0002\u0002\u0002\u15d5\u15d6\u0007\u008c\u0002\u0002\u15d6\u15d7\t", + "\u001d\u0002\u0002\u15d7\u15d8\u0005\u0274\u013b\u0002\u15d8\u15d9\u0005", + "\u02a2\u0152\u0002\u15d9\u15da\u0005\u02a4\u0153\u0002\u15da\u02a1\u0003", + "\u0002\u0002\u0002\u15db\u15dd\u0005\u0292\u014a\u0002\u15dc\u15db\u0003", + "\u0002\u0002\u0002\u15dd\u15de\u0003\u0002\u0002\u0002\u15de\u15dc\u0003", + "\u0002\u0002\u0002\u15de\u15df\u0003\u0002\u0002\u0002\u15df\u02a3\u0003", + "\u0002\u0002\u0002\u15e0\u15e3\u0007\u0134\u0002\u0002\u15e1\u15e3\u0003", + "\u0002\u0002\u0002\u15e2\u15e0\u0003\u0002\u0002\u0002\u15e2\u15e1\u0003", + "\u0002\u0002\u0002\u15e3\u02a5\u0003\u0002\u0002\u0002\u15e4\u15e5\u0007", + "\u00c1\u0002\u0002\u15e5\u15e6\u0007\u00d5\u0002\u0002\u15e6\u15e7\u0005", + "\u0272\u013a\u0002\u15e7\u15e8\u0005n8\u0002\u15e8\u1609\u0003\u0002", + "\u0002\u0002\u15e9\u15ea\u0007\u00c1\u0002\u0002\u15ea\u15eb\u0007\u00d5", + "\u0002\u0002\u15eb\u15ec\u0007\u00de\u0002\u0002\u15ec\u15ed\u0007\u0185", + "\u0002\u0002\u15ed\u15ee\u0005\u0272\u013a\u0002\u15ee\u15ef\u0005n", + "8\u0002\u15ef\u1609\u0003\u0002\u0002\u0002\u15f0\u15f1\u0007\u00c1", + "\u0002\u0002\u15f1\u15f2\u0007\u0121\u0002\u0002\u15f2\u15f3\u0005\u0272", + "\u013a\u0002\u15f3\u15f4\u0005n8\u0002\u15f4\u1609\u0003\u0002\u0002", + "\u0002\u15f5\u15f6\u0007\u00c1\u0002\u0002\u15f6\u15f7\u0007\u0121\u0002", + "\u0002\u15f7\u15f8\u0007\u00de\u0002\u0002\u15f8\u15f9\u0007\u0185\u0002", + "\u0002\u15f9\u15fa\u0005\u0272\u013a\u0002\u15fa\u15fb\u0005n8\u0002", + "\u15fb\u1609\u0003\u0002\u0002\u0002\u15fc\u15fd\u0007\u00c1\u0002\u0002", + "\u15fd\u15fe\u0007\u01b3\u0002\u0002\u15fe\u15ff\u0005\u0272\u013a\u0002", + "\u15ff\u1600\u0005n8\u0002\u1600\u1609\u0003\u0002\u0002\u0002\u1601", + "\u1602\u0007\u00c1\u0002\u0002\u1602\u1603\u0007\u01b3\u0002\u0002\u1603", + "\u1604\u0007\u00de\u0002\u0002\u1604\u1605\u0007\u0185\u0002\u0002\u1605", + "\u1606\u0005\u0272\u013a\u0002\u1606\u1607\u0005n8\u0002\u1607\u1609", + "\u0003\u0002\u0002\u0002\u1608\u15e4\u0003\u0002\u0002\u0002\u1608\u15e9", + "\u0003\u0002\u0002\u0002\u1608\u15f0\u0003\u0002\u0002\u0002\u1608\u15f5", + "\u0003\u0002\u0002\u0002\u1608\u15fc\u0003\u0002\u0002\u0002\u1608\u1601", + "\u0003\u0002\u0002\u0002\u1609\u02a7\u0003\u0002\u0002\u0002\u160a\u160b", + "\u0007\u00c1\u0002\u0002\u160b\u160c\u0007\u008a\u0002\u0002\u160c\u160d", + "\u0005\u028e\u0148\u0002\u160d\u160e\u0005n8\u0002\u160e\u1617\u0003", + "\u0002\u0002\u0002\u160f\u1610\u0007\u00c1\u0002\u0002\u1610\u1611\u0007", + "\u008a\u0002\u0002\u1611\u1612\u0007\u00de\u0002\u0002\u1612\u1613\u0007", + "\u0185\u0002\u0002\u1613\u1614\u0005\u028e\u0148\u0002\u1614\u1615\u0005", + "n8\u0002\u1615\u1617\u0003\u0002\u0002\u0002\u1616\u160a\u0003\u0002", + "\u0002\u0002\u1616\u160f\u0003\u0002\u0002\u0002\u1617\u02a9\u0003\u0002", + "\u0002\u0002\u1618\u1619\u0007\u00c1\u0002\u0002\u1619\u161a\u0007\u010f", + "\u0002\u0002\u161a\u161b\u0005\u02b0\u0159\u0002\u161b\u161c\u0005n", + "8\u0002\u161c\u1625\u0003\u0002\u0002\u0002\u161d\u161e\u0007\u00c1", + "\u0002\u0002\u161e\u161f\u0007\u010f\u0002\u0002\u161f\u1620\u0007\u00de", + "\u0002\u0002\u1620\u1621\u0007\u0185\u0002\u0002\u1621\u1622\u0005\u02b0", + "\u0159\u0002\u1622\u1623\u0005n8\u0002\u1623\u1625\u0003\u0002\u0002", + "\u0002\u1624\u1618\u0003\u0002\u0002\u0002\u1624\u161d\u0003\u0002\u0002", + "\u0002\u1625\u02ab\u0003\u0002\u0002\u0002\u1626\u1627\u0007\u0004\u0002", + "\u0002\u1627\u1628\u0005\u0456\u022c\u0002\u1628\u1629\u0007\u0005\u0002", + "\u0002\u1629\u163d\u0003\u0002\u0002\u0002\u162a\u162b\u0007\u0004\u0002", + "\u0002\u162b\u162c\u0005\u0456\u022c\u0002\u162c\u162d\u0007\b\u0002", + "\u0002\u162d\u162e\u0005\u0456\u022c\u0002\u162e\u162f\u0007\u0005\u0002", + "\u0002\u162f\u163d\u0003\u0002\u0002\u0002\u1630\u1631\u0007\u0004\u0002", + "\u0002\u1631\u1632\u0007\u0190\u0002\u0002\u1632\u1633\u0007\b\u0002", + "\u0002\u1633\u1634\u0005\u0456\u022c\u0002\u1634\u1635\u0007\u0005\u0002", + "\u0002\u1635\u163d\u0003\u0002\u0002\u0002\u1636\u1637\u0007\u0004\u0002", + "\u0002\u1637\u1638\u0005\u0456\u022c\u0002\u1638\u1639\u0007\b\u0002", + "\u0002\u1639\u163a\u0007\u0190\u0002\u0002\u163a\u163b\u0007\u0005\u0002", + "\u0002\u163b\u163d\u0003\u0002\u0002\u0002\u163c\u1626\u0003\u0002\u0002", + "\u0002\u163c\u162a\u0003\u0002\u0002\u0002\u163c\u1630\u0003\u0002\u0002", + "\u0002\u163c\u1636\u0003\u0002\u0002\u0002\u163d\u02ad\u0003\u0002\u0002", + "\u0002\u163e\u163f\u0005\u0552\u02aa\u0002\u163f\u1640\u0007\r\u0002", + "\u0002\u1640\u1642\u0003\u0002\u0002\u0002\u1641\u163e\u0003\u0002\u0002", + "\u0002\u1642\u1645\u0003\u0002\u0002\u0002\u1643\u1641\u0003\u0002\u0002", + "\u0002\u1643\u1644\u0003\u0002\u0002\u0002\u1644\u1646\u0003\u0002\u0002", + "\u0002\u1645\u1643\u0003\u0002\u0002\u0002\u1646\u1647\u0005\u04ec\u0277", + "\u0002\u1647\u02af\u0003\u0002\u0002\u0002\u1648\u164d\u0005\u02b2\u015a", + "\u0002\u1649\u164a\u0007\b\u0002\u0002\u164a\u164c\u0005\u02b2\u015a", + "\u0002\u164b\u1649\u0003\u0002\u0002\u0002\u164c\u164f\u0003\u0002\u0002", + "\u0002\u164d\u164b\u0003\u0002\u0002\u0002\u164d\u164e\u0003\u0002\u0002", + "\u0002\u164e\u02b1\u0003\u0002\u0002\u0002\u164f\u164d\u0003\u0002\u0002", + "\u0002\u1650\u1651\u0005\u02ae\u0158\u0002\u1651\u1652\u0005\u02ac\u0157", + "\u0002\u1652\u02b3\u0003\u0002\u0002\u0002\u1653\u1654\u0007;\u0002", + "\u0002\u1654\u1655\u0005\u02b6\u015c\u0002\u1655\u02b5\u0003\u0002\u0002", + "\u0002\u1656\u1658\u0005\u02b8\u015d\u0002\u1657\u1656\u0003\u0002\u0002", + "\u0002\u1658\u1659\u0003\u0002\u0002\u0002\u1659\u1657\u0003\u0002\u0002", + "\u0002\u1659\u165a\u0003\u0002\u0002\u0002\u165a\u02b7\u0003\u0002\u0002", + "\u0002\u165b\u165f\u0005\u0544\u02a3\u0002\u165c\u165d\u0007\u00f0\u0002", + "\u0002\u165d\u165f\u0005J&\u0002\u165e\u165b\u0003\u0002\u0002\u0002", + "\u165e\u165c\u0003\u0002\u0002\u0002\u165f\u02b9\u0003\u0002\u0002\u0002", + "\u1660\u1661\u00070\u0002\u0002\u1661\u1662\u0007+\u0002\u0002\u1662", + "\u1663\u0007\u0004\u0002\u0002\u1663\u1664\u0005\u0456\u022c\u0002\u1664", + "\u1665\u0007&\u0002\u0002\u1665\u1666\u0005\u0456\u022c\u0002\u1666", + "\u1667\u0007\u0005\u0002\u0002\u1667\u1668\u0007k\u0002\u0002\u1668", + "\u1669\u0007\u00d5\u0002\u0002\u1669\u166a\u0005\u0274\u013b\u0002\u166a", + "\u166b\u0005\u02bc\u015f\u0002\u166b\u1683\u0003\u0002\u0002\u0002\u166c", + "\u166d\u00070\u0002\u0002\u166d\u166e\u0007+\u0002\u0002\u166e\u166f", + "\u0007\u0004\u0002\u0002\u166f\u1670\u0005\u0456\u022c\u0002\u1670\u1671", + "\u0007&\u0002\u0002\u1671\u1672\u0005\u0456\u022c\u0002\u1672\u1673", + "\u0007\u0005\u0002\u0002\u1673\u1674\u0007\u0174\u0002\u0002\u1674\u1675", + "\u0007\u00d5\u0002\u0002\u1675\u1676\u0005\u02bc\u015f\u0002\u1676\u1683", + "\u0003\u0002\u0002\u0002\u1677\u1678\u00070\u0002\u0002\u1678\u1679", + "\u0007+\u0002\u0002\u1679\u167a\u0007\u0004\u0002\u0002\u167a\u167b", + "\u0005\u0456\u022c\u0002\u167b\u167c\u0007&\u0002\u0002\u167c\u167d", + "\u0005\u0456\u022c\u0002\u167d\u167e\u0007\u0005\u0002\u0002\u167e\u167f", + "\u0007k\u0002\u0002\u167f\u1680\u0007\u0189\u0002\u0002\u1680\u1681", + "\u0005\u02bc\u015f\u0002\u1681\u1683\u0003\u0002\u0002\u0002\u1682\u1660", + "\u0003\u0002\u0002\u0002\u1682\u166c\u0003\u0002\u0002\u0002\u1682\u1677", + "\u0003\u0002\u0002\u0002\u1683\u02bb\u0003\u0002\u0002\u0002\u1684\u1685", + "\u0007&\u0002\u0002\u1685\u168a\u0007\u00e1\u0002\u0002\u1686\u1687", + "\u0007&\u0002\u0002\u1687\u168a\u0007\u008f\u0002\u0002\u1688\u168a", + "\u0003\u0002\u0002\u0002\u1689\u1684\u0003\u0002\u0002\u0002\u1689\u1686", + "\u0003\u0002\u0002\u0002\u1689\u1688\u0003\u0002\u0002\u0002\u168a\u02bd", + "\u0003\u0002\u0002\u0002\u168b\u168c\u0007\u00c1\u0002\u0002\u168c\u168d", + "\u0007+\u0002\u0002\u168d\u168e\u0005\u02c0\u0161\u0002\u168e\u168f", + "\u0007\u0004\u0002\u0002\u168f\u1690\u0005\u0456\u022c\u0002\u1690\u1691", + "\u0007&\u0002\u0002\u1691\u1692\u0005\u0456\u022c\u0002\u1692\u1693", + "\u0007\u0005\u0002\u0002\u1693\u1694\u0005n8\u0002\u1694\u02bf\u0003", + "\u0002\u0002\u0002\u1695\u1696\u0007\u00de\u0002\u0002\u1696\u1699\u0007", + "\u0185\u0002\u0002\u1697\u1699\u0003\u0002\u0002\u0002\u1698\u1695\u0003", + "\u0002\u0002\u0002\u1698\u1697\u0003\u0002\u0002\u0002\u1699\u02c1\u0003", + "\u0002\u0002\u0002\u169a\u169b\u00070\u0002\u0002\u169b\u169c\u0005", + "\u026c\u0137\u0002\u169c\u169d\u0007\u01b4\u0002\u0002\u169d\u169e\u0007", + "@\u0002\u0002\u169e\u169f\u0005\u0456\u022c\u0002\u169f\u16a0\u0007", + "\u00f0\u0002\u0002\u16a0\u16a1\u0005\u0532\u029a\u0002\u16a1\u16a2\u0007", + "\u0004\u0002\u0002\u16a2\u16a3\u0005\u02c4\u0163\u0002\u16a3\u16a4\u0007", + "\u0005\u0002\u0002\u16a4\u02c3\u0003\u0002\u0002\u0002\u16a5\u16a6\u0007", + "B\u0002\u0002\u16a6\u16a7\u0007\u01c6\u0002\u0002\u16a7\u16a8\u0007", + "k\u0002\u0002\u16a8\u16a9\u0007\u00d5\u0002\u0002\u16a9\u16aa\u0005", + "\u0274\u013b\u0002\u16aa\u16ab\u0007\b\u0002\u0002\u16ab\u16ac\u0007", + "`\u0002\u0002\u16ac\u16ad\u0007\u01c6\u0002\u0002\u16ad\u16ae\u0007", + "k\u0002\u0002\u16ae\u16af\u0007\u00d5\u0002\u0002\u16af\u16b0\u0005", + "\u0274\u013b\u0002\u16b0\u16c8\u0003\u0002\u0002\u0002\u16b1\u16b2\u0007", + "`\u0002\u0002\u16b2\u16b3\u0007\u01c6\u0002\u0002\u16b3\u16b4\u0007", + "k\u0002\u0002\u16b4\u16b5\u0007\u00d5\u0002\u0002\u16b5\u16b6\u0005", + "\u0274\u013b\u0002\u16b6\u16b7\u0007\b\u0002\u0002\u16b7\u16b8\u0007", + "B\u0002\u0002\u16b8\u16b9\u0007\u01c6\u0002\u0002\u16b9\u16ba\u0007", + "k\u0002\u0002\u16ba\u16bb\u0007\u00d5\u0002\u0002\u16bb\u16bc\u0005", + "\u0274\u013b\u0002\u16bc\u16c8\u0003\u0002\u0002\u0002\u16bd\u16be\u0007", + "B\u0002\u0002\u16be\u16bf\u0007\u01c6\u0002\u0002\u16bf\u16c0\u0007", + "k\u0002\u0002\u16c0\u16c1\u0007\u00d5\u0002\u0002\u16c1\u16c8\u0005", + "\u0274\u013b\u0002\u16c2\u16c3\u0007`\u0002\u0002\u16c3\u16c4\u0007", + "\u01c6\u0002\u0002\u16c4\u16c5\u0007k\u0002\u0002\u16c5\u16c6\u0007", + "\u00d5\u0002\u0002\u16c6\u16c8\u0005\u0274\u013b\u0002\u16c7\u16a5\u0003", + "\u0002\u0002\u0002\u16c7\u16b1\u0003\u0002\u0002\u0002\u16c7\u16bd\u0003", + "\u0002\u0002\u0002\u16c7\u16c2\u0003\u0002\u0002\u0002\u16c8\u02c5\u0003", + "\u0002\u0002\u0002\u16c9\u16ca\u0007\u00c1\u0002\u0002\u16ca\u16cb\u0007", + "\u01b4\u0002\u0002\u16cb\u16cc\u0005\u02c0\u0161\u0002\u16cc\u16cd\u0007", + "@\u0002\u0002\u16cd\u16ce\u0005\u0456\u022c\u0002\u16ce\u16cf\u0007", + "\u00f0\u0002\u0002\u16cf\u16d0\u0005\u0532\u029a\u0002\u16d0\u16d1\u0005", + "n8\u0002\u16d1\u02c7\u0003\u0002\u0002\u0002\u16d2\u16d3\u0007\u012b", + "\u0002\u0002\u16d3\u16d4\u0005\u02ca\u0166\u0002\u16d4\u16d5\u0005\u0252", + "\u012a\u0002\u16d5\u16d6\u0005\u052e\u0298\u0002\u16d6\u16ed\u0003\u0002", + "\u0002\u0002\u16d7\u16d8\u0007\u012b\u0002\u0002\u16d8\u16d9\u0005\u02cc", + "\u0167\u0002\u16d9\u16da\u0005\u0252\u012a\u0002\u16da\u16db\u0005\u0532", + "\u029a\u0002\u16db\u16ed\u0003\u0002\u0002\u0002\u16dc\u16dd\u0007\u012b", + "\u0002\u0002\u16dd\u16de\u0007\u0004\u0002\u0002\u16de\u16df\u0005\u02ce", + "\u0168\u0002\u16df\u16e0\u0007\u0005\u0002\u0002\u16e0\u16e1\u0005\u02ca", + "\u0166\u0002\u16e1\u16e2\u0005\u0252\u012a\u0002\u16e2\u16e3\u0005\u052e", + "\u0298\u0002\u16e3\u16ed\u0003\u0002\u0002\u0002\u16e4\u16e5\u0007\u012b", + "\u0002\u0002\u16e5\u16e6\u0007\u0004\u0002\u0002\u16e6\u16e7\u0005\u02ce", + "\u0168\u0002\u16e7\u16e8\u0007\u0005\u0002\u0002\u16e8\u16e9\u0005\u02cc", + "\u0167\u0002\u16e9\u16ea\u0005\u0252\u012a\u0002\u16ea\u16eb\u0005\u0532", + "\u029a\u0002\u16eb\u16ed\u0003\u0002\u0002\u0002\u16ec\u16d2\u0003\u0002", + "\u0002\u0002\u16ec\u16d7\u0003\u0002\u0002\u0002\u16ec\u16dc\u0003\u0002", + "\u0002\u0002\u16ec\u16e4\u0003\u0002\u0002\u0002\u16ed\u02c9\u0003\u0002", + "\u0002\u0002\u16ee\u16ef\t\u0014\u0002\u0002\u16ef\u02cb\u0003\u0002", + "\u0002\u0002\u16f0\u16f1\t\u001e\u0002\u0002\u16f1\u02cd\u0003\u0002", + "\u0002\u0002\u16f2\u16f7\u0005\u02d0\u0169\u0002\u16f3\u16f4\u0007\b", + "\u0002\u0002\u16f4\u16f6\u0005\u02d0\u0169\u0002\u16f5\u16f3\u0003\u0002", + "\u0002\u0002\u16f6\u16f9\u0003\u0002\u0002\u0002\u16f7\u16f5\u0003\u0002", + "\u0002\u0002\u16f7\u16f8\u0003\u0002\u0002\u0002\u16f8\u02cf\u0003\u0002", + "\u0002\u0002\u16f9\u16f7\u0003\u0002\u0002\u0002\u16fa\u16fb\u0007\u0082", + "\u0002\u0002\u16fb\u02d1\u0003\u0002\u0002\u0002\u16fc\u16fd\u0007\u008c", + "\u0002\u0002\u16fd\u16fe\u0007\u0158\u0002\u0002\u16fe\u16ff\u0005\u0532", + "\u029a\u0002\u16ff\u1700\u0007\u0146\u0002\u0002\u1700\u1701\u0005v", + "<\u0002\u1701\u1709\u0003\u0002\u0002\u0002\u1702\u1703\u0007\u008c", + "\u0002\u0002\u1703\u1704\u0007\u0158\u0002\u0002\u1704\u1705\u0005\u0532", + "\u029a\u0002\u1705\u1706\u0007\u0132\u0002\u0002\u1706\u1707\u0005v", + "<\u0002\u1707\u1709\u0003\u0002\u0002\u0002\u1708\u16fc\u0003\u0002", + "\u0002\u0002\u1708\u1702\u0003\u0002\u0002\u0002\u1709\u02d3\u0003\u0002", + "\u0002\u0002\u170a\u170b\u0007\u008c\u0002\u0002\u170b\u170c\u0007\u008a", + "\u0002\u0002\u170c\u170d\u0005\u028c\u0147\u0002\u170d\u170e\u0007\u012e", + "\u0002\u0002\u170e\u170f\u0007`\u0002\u0002\u170f\u1710\u0005\u0532", + "\u029a\u0002\u1710\u18df\u0003\u0002\u0002\u0002\u1711\u1712\u0007\u008c", + "\u0002\u0002\u1712\u1713\u0007n\u0002\u0002\u1713\u1714\u0005\u020e", + "\u0108\u0002\u1714\u1715\u0007\u012e\u0002\u0002\u1715\u1716\u0007`", + "\u0002\u0002\u1716\u1717\u0005\u0532\u029a\u0002\u1717\u18df\u0003\u0002", + "\u0002\u0002\u1718\u1719\u0007\u008c\u0002\u0002\u1719\u171a\u0007\u00aa", + "\u0002\u0002\u171a\u171b\u0005\u020e\u0108\u0002\u171b\u171c\u0007\u012e", + "\u0002\u0002\u171c\u171d\u0007`\u0002\u0002\u171d\u171e\u0005\u0532", + "\u029a\u0002\u171e\u18df\u0003\u0002\u0002\u0002\u171f\u1720\u0007\u008c", + "\u0002\u0002\u1720\u1721\u0007\u00b1\u0002\u0002\u1721\u1722\u0005\u0532", + "\u029a\u0002\u1722\u1723\u0007\u012e\u0002\u0002\u1723\u1724\u0007`", + "\u0002\u0002\u1724\u1725\u0005\u0532\u029a\u0002\u1725\u18df\u0003\u0002", + "\u0002\u0002\u1726\u1727\u0007\u008c\u0002\u0002\u1727\u1728\u0007\u00bf", + "\u0002\u0002\u1728\u1729\u0005\u020e\u0108\u0002\u1729\u172a\u0007\u012e", + "\u0002\u0002\u172a\u172b\u0007`\u0002\u0002\u172b\u172c\u0005\u0532", + "\u029a\u0002\u172c\u18df\u0003\u0002\u0002\u0002\u172d\u172e\u0007\u008c", + "\u0002\u0002\u172e\u172f\u0007\u00bf\u0002\u0002\u172f\u1730\u0005\u020e", + "\u0108\u0002\u1730\u1731\u0007\u012e\u0002\u0002\u1731\u1732\u0007/", + "\u0002\u0002\u1732\u1733\u0005\u0532\u029a\u0002\u1733\u1734\u0007`", + "\u0002\u0002\u1734\u1735\u0005\u0532\u029a\u0002\u1735\u18df\u0003\u0002", + "\u0002\u0002\u1736\u1737\u0007\u008c\u0002\u0002\u1737\u1738\u0007A", + "\u0002\u0002\u1738\u1739\u0007\u00b0\u0002\u0002\u1739\u173a\u0007\u0176", + "\u0002\u0002\u173a\u173b\u0005\u0532\u029a\u0002\u173b\u173c\u0007\u012e", + "\u0002\u0002\u173c\u173d\u0007`\u0002\u0002\u173d\u173e\u0005\u0532", + "\u029a\u0002\u173e\u18df\u0003\u0002\u0002\u0002\u173f\u1740\u0007\u008c", + "\u0002\u0002\u1740\u1741\u0007\u00d5\u0002\u0002\u1741\u1742\u0005\u0274", + "\u013b\u0002\u1742\u1743\u0007\u012e\u0002\u0002\u1743\u1744\u0007`", + "\u0002\u0002\u1744\u1745\u0005\u0532\u029a\u0002\u1745\u18df\u0003\u0002", + "\u0002\u0002\u1746\u1747\u0007\u008c\u0002\u0002\u1747\u1748\u0007D", + "\u0002\u0002\u1748\u1749\u0005\u054c\u02a7\u0002\u1749\u174a\u0007\u012e", + "\u0002\u0002\u174a\u174b\u0007`\u0002\u0002\u174b\u174c\u0005\u054c", + "\u02a7\u0002\u174c\u18df\u0003\u0002\u0002\u0002\u174d\u174e\u0007\u008c", + "\u0002\u0002\u174e\u174f\u0005\u0136\u009c\u0002\u174f\u1750\u0007\u00f0", + "\u0002\u0002\u1750\u1751\u0005\u0532\u029a\u0002\u1751\u1752\u0007\u012e", + "\u0002\u0002\u1752\u1753\u0007`\u0002\u0002\u1753\u1754\u0005\u0532", + "\u029a\u0002\u1754\u18df\u0003\u0002\u0002\u0002\u1755\u1756\u0007\u008c", + "\u0002\u0002\u1756\u1757\u0007\u010f\u0002\u0002\u1757\u1758\u0007\u009e", + "\u0002\u0002\u1758\u1759\u0005\u020e\u0108\u0002\u1759\u175a\u0007f", + "\u0002\u0002\u175a\u175b\u0005\u0532\u029a\u0002\u175b\u175c\u0007\u012e", + "\u0002\u0002\u175c\u175d\u0007`\u0002\u0002\u175d\u175e\u0005\u0532", + "\u029a\u0002\u175e\u18df\u0003\u0002\u0002\u0002\u175f\u1760\u0007\u008c", + "\u0002\u0002\u1760\u1761\u0007\u010f\u0002\u0002\u1761\u1762\u0007\u00d0", + "\u0002\u0002\u1762\u1763\u0005\u020e\u0108\u0002\u1763\u1764\u0007f", + "\u0002\u0002\u1764\u1765\u0005\u0532\u029a\u0002\u1765\u1766\u0007\u012e", + "\u0002\u0002\u1766\u1767\u0007`\u0002\u0002\u1767\u1768\u0005\u0532", + "\u029a\u0002\u1768\u18df\u0003\u0002\u0002\u0002\u1769\u176a\u0007\u008c", + "\u0002\u0002\u176a\u176b\u0007\u01b6\u0002\u0002\u176b\u176c\u0005\u0532", + "\u029a\u0002\u176c\u176d\u0007R\u0002\u0002\u176d\u176e\u0005\u052e", + "\u0298\u0002\u176e\u176f\u0007\u012e\u0002\u0002\u176f\u1770\u0007`", + "\u0002\u0002\u1770\u1771\u0005\u0532\u029a\u0002\u1771\u18df\u0003\u0002", + "\u0002\u0002\u1772\u1773\u0007\u008c\u0002\u0002\u1773\u1774\u0007\u01b6", + "\u0002\u0002\u1774\u1775\u0007\u00de\u0002\u0002\u1775\u1776\u0007\u0185", + "\u0002\u0002\u1776\u1777\u0005\u0532\u029a\u0002\u1777\u1778\u0007R", + "\u0002\u0002\u1778\u1779\u0005\u052e\u0298\u0002\u1779\u177a\u0007\u012e", + "\u0002\u0002\u177a\u177b\u0007`\u0002\u0002\u177b\u177c\u0005\u0532", + "\u029a\u0002\u177c\u18df\u0003\u0002\u0002\u0002\u177d\u177e\u0007\u008c", + "\u0002\u0002\u177e\u177f\u0007\u0121\u0002\u0002\u177f\u1780\u0005\u0274", + "\u013b\u0002\u1780\u1781\u0007\u012e\u0002\u0002\u1781\u1782\u0007`", + "\u0002\u0002\u1782\u1783\u0005\u0532\u029a\u0002\u1783\u18df\u0003\u0002", + "\u0002\u0002\u1784\u1785\u0007\u008c\u0002\u0002\u1785\u1786\u0007\u01bd", + "\u0002\u0002\u1786\u1787\u0005\u0532\u029a\u0002\u1787\u1788\u0007\u012e", + "\u0002\u0002\u1788\u1789\u0007`\u0002\u0002\u1789\u178a\u0005\u0532", + "\u029a\u0002\u178a\u18df\u0003\u0002\u0002\u0002\u178b\u178c\u0007\u008c", + "\u0002\u0002\u178c\u178d\u0007\u01b3\u0002\u0002\u178d\u178e\u0005\u0274", + "\u013b\u0002\u178e\u178f\u0007\u012e\u0002\u0002\u178f\u1790\u0007`", + "\u0002\u0002\u1790\u1791\u0005\u0532\u029a\u0002\u1791\u18df\u0003\u0002", + "\u0002\u0002\u1792\u1793\u0007\u008c\u0002\u0002\u1793\u1794\u0007\u013c", + "\u0002\u0002\u1794\u1795\u0005\u0532\u029a\u0002\u1795\u1796\u0007\u012e", + "\u0002\u0002\u1796\u1797\u0007`\u0002\u0002\u1797\u1798\u0005\u0532", + "\u029a\u0002\u1798\u18df\u0003\u0002\u0002\u0002\u1799\u179a\u0007\u008c", + "\u0002\u0002\u179a\u179b\u0007\u0144\u0002\u0002\u179b\u179c\u0005\u0532", + "\u029a\u0002\u179c\u179d\u0007\u012e\u0002\u0002\u179d\u179e\u0007`", + "\u0002\u0002\u179e\u179f\u0005\u0532\u029a\u0002\u179f\u18df\u0003\u0002", + "\u0002\u0002\u17a0\u17a1\u0007\u008c\u0002\u0002\u17a1\u17a2\u0007\u01bc", + "\u0002\u0002\u17a2\u17a3\u0005\u0532\u029a\u0002\u17a3\u17a4\u0007\u012e", + "\u0002\u0002\u17a4\u17a5\u0007`\u0002\u0002\u17a5\u17a6\u0005\u0532", + "\u029a\u0002\u17a6\u18df\u0003\u0002\u0002\u0002\u17a7\u17a8\u0007\u008c", + "\u0002\u0002\u17a8\u17a9\u0007^\u0002\u0002\u17a9\u17aa\u0005\u042a", + "\u0216\u0002\u17aa\u17ab\u0007\u012e\u0002\u0002\u17ab\u17ac\u0007`", + "\u0002\u0002\u17ac\u17ad\u0005\u0532\u029a\u0002\u17ad\u18df\u0003\u0002", + "\u0002\u0002\u17ae\u17af\u0007\u008c\u0002\u0002\u17af\u17b0\u0007^", + "\u0002\u0002\u17b0\u17b1\u0007\u00de\u0002\u0002\u17b1\u17b2\u0007\u0185", + "\u0002\u0002\u17b2\u17b3\u0005\u042a\u0216\u0002\u17b3\u17b4\u0007\u012e", + "\u0002\u0002\u17b4\u17b5\u0007`\u0002\u0002\u17b5\u17b6\u0005\u0532", + "\u029a\u0002\u17b6\u18df\u0003\u0002\u0002\u0002\u17b7\u17b8\u0007\u008c", + "\u0002\u0002\u17b8\u17b9\u0007\u0141\u0002\u0002\u17b9\u17ba\u0005\u052e", + "\u0298\u0002\u17ba\u17bb\u0007\u012e\u0002\u0002\u17bb\u17bc\u0007`", + "\u0002\u0002\u17bc\u17bd\u0005\u0532\u029a\u0002\u17bd\u18df\u0003\u0002", + "\u0002\u0002\u17be\u17bf\u0007\u008c\u0002\u0002\u17bf\u17c0\u0007\u0141", + "\u0002\u0002\u17c0\u17c1\u0007\u00de\u0002\u0002\u17c1\u17c2\u0007\u0185", + "\u0002\u0002\u17c2\u17c3\u0005\u052e\u0298\u0002\u17c3\u17c4\u0007\u012e", + "\u0002\u0002\u17c4\u17c5\u0007`\u0002\u0002\u17c5\u17c6\u0005\u0532", + "\u029a\u0002\u17c6\u18df\u0003\u0002\u0002\u0002\u17c7\u17c8\u0007\u008c", + "\u0002\u0002\u17c8\u17c9\u0007\u0171\u0002\u0002\u17c9\u17ca\u0005\u052e", + "\u0298\u0002\u17ca\u17cb\u0007\u012e\u0002\u0002\u17cb\u17cc\u0007`", + "\u0002\u0002\u17cc\u17cd\u0005\u0532\u029a\u0002\u17cd\u18df\u0003\u0002", + "\u0002\u0002\u17ce\u17cf\u0007\u008c\u0002\u0002\u17cf\u17d0\u0007\u0171", + "\u0002\u0002\u17d0\u17d1\u0007\u00de\u0002\u0002\u17d1\u17d2\u0007\u0185", + "\u0002\u0002\u17d2\u17d3\u0005\u052e\u0298\u0002\u17d3\u17d4\u0007\u012e", + "\u0002\u0002\u17d4\u17d5\u0007`\u0002\u0002\u17d5\u17d6\u0005\u0532", + "\u029a\u0002\u17d6\u18df\u0003\u0002\u0002\u0002\u17d7\u17d8\u0007\u008c", + "\u0002\u0002\u17d8\u17d9\u0007\u00fc\u0002\u0002\u17d9\u17da\u0007\u0171", + "\u0002\u0002\u17da\u17db\u0005\u052e\u0298\u0002\u17db\u17dc\u0007\u012e", + "\u0002\u0002\u17dc\u17dd\u0007`\u0002\u0002\u17dd\u17de\u0005\u0532", + "\u029a\u0002\u17de\u18df\u0003\u0002\u0002\u0002\u17df\u17e0\u0007\u008c", + "\u0002\u0002\u17e0\u17e1\u0007\u00fc\u0002\u0002\u17e1\u17e2\u0007\u0171", + "\u0002\u0002\u17e2\u17e3\u0007\u00de\u0002\u0002\u17e3\u17e4\u0007\u0185", + "\u0002\u0002\u17e4\u17e5\u0005\u052e\u0298\u0002\u17e5\u17e6\u0007\u012e", + "\u0002\u0002\u17e6\u17e7\u0007`\u0002\u0002\u17e7\u17e8\u0005\u0532", + "\u029a\u0002\u17e8\u18df\u0003\u0002\u0002\u0002\u17e9\u17ea\u0007\u008c", + "\u0002\u0002\u17ea\u17eb\u0007\u00e4\u0002\u0002\u17eb\u17ec\u0005\u052e", + "\u0298\u0002\u17ec\u17ed\u0007\u012e\u0002\u0002\u17ed\u17ee\u0007`", + "\u0002\u0002\u17ee\u17ef\u0005\u0532\u029a\u0002\u17ef\u18df\u0003\u0002", + "\u0002\u0002\u17f0\u17f1\u0007\u008c\u0002\u0002\u17f1\u17f2\u0007\u00e4", + "\u0002\u0002\u17f2\u17f3\u0007\u00de\u0002\u0002\u17f3\u17f4\u0007\u0185", + "\u0002\u0002\u17f4\u17f5\u0005\u052e\u0298\u0002\u17f5\u17f6\u0007\u012e", + "\u0002\u0002\u17f6\u17f7\u0007`\u0002\u0002\u17f7\u17f8\u0005\u0532", + "\u029a\u0002\u17f8\u18df\u0003\u0002\u0002\u0002\u17f9\u17fa\u0007\u008c", + "\u0002\u0002\u17fa\u17fb\u0007A\u0002\u0002\u17fb\u17fc\u0007^\u0002", + "\u0002\u17fc\u17fd\u0005\u042a\u0216\u0002\u17fd\u17fe\u0007\u012e\u0002", + "\u0002\u17fe\u17ff\u0007`\u0002\u0002\u17ff\u1800\u0005\u0532\u029a", + "\u0002\u1800\u18df\u0003\u0002\u0002\u0002\u1801\u1802\u0007\u008c\u0002", + "\u0002\u1802\u1803\u0007A\u0002\u0002\u1803\u1804\u0007^\u0002\u0002", + "\u1804\u1805\u0007\u00de\u0002\u0002\u1805\u1806\u0007\u0185\u0002\u0002", + "\u1806\u1807\u0005\u042a\u0216\u0002\u1807\u1808\u0007\u012e\u0002\u0002", + "\u1808\u1809\u0007`\u0002\u0002\u1809\u180a\u0005\u0532\u029a\u0002", + "\u180a\u18df\u0003\u0002\u0002\u0002\u180b\u180c\u0007\u008c\u0002\u0002", + "\u180c\u180d\u0007^\u0002\u0002\u180d\u180e\u0005\u042a\u0216\u0002", + "\u180e\u180f\u0007\u012e\u0002\u0002\u180f\u1810\u0005\u02d6\u016c\u0002", + "\u1810\u1811\u0005\u0532\u029a\u0002\u1811\u1812\u0007`\u0002\u0002", + "\u1812\u1813\u0005\u0532\u029a\u0002\u1813\u18df\u0003\u0002\u0002\u0002", + "\u1814\u1815\u0007\u008c\u0002\u0002\u1815\u1816\u0007^\u0002\u0002", + "\u1816\u1817\u0007\u00de\u0002\u0002\u1817\u1818\u0007\u0185\u0002\u0002", + "\u1818\u1819\u0005\u042a\u0216\u0002\u1819\u181a\u0007\u012e\u0002\u0002", + "\u181a\u181b\u0005\u02d6\u016c\u0002\u181b\u181c\u0005\u0532\u029a\u0002", + "\u181c\u181d\u0007`\u0002\u0002\u181d\u181e\u0005\u0532\u029a\u0002", + "\u181e\u18df\u0003\u0002\u0002\u0002\u181f\u1820\u0007\u008c\u0002\u0002", + "\u1820\u1821\u0007\u0171\u0002\u0002\u1821\u1822\u0005\u052e\u0298\u0002", + "\u1822\u1823\u0007\u012e\u0002\u0002\u1823\u1824\u0005\u02d6\u016c\u0002", + "\u1824\u1825\u0005\u0532\u029a\u0002\u1825\u1826\u0007`\u0002\u0002", + "\u1826\u1827\u0005\u0532\u029a\u0002\u1827\u18df\u0003\u0002\u0002\u0002", + "\u1828\u1829\u0007\u008c\u0002\u0002\u1829\u182a\u0007\u0171\u0002\u0002", + "\u182a\u182b\u0007\u00de\u0002\u0002\u182b\u182c\u0007\u0185\u0002\u0002", + "\u182c\u182d\u0005\u052e\u0298\u0002\u182d\u182e\u0007\u012e\u0002\u0002", + "\u182e\u182f\u0005\u02d6\u016c\u0002\u182f\u1830\u0005\u0532\u029a\u0002", + "\u1830\u1831\u0007`\u0002\u0002\u1831\u1832\u0005\u0532\u029a\u0002", + "\u1832\u18df\u0003\u0002\u0002\u0002\u1833\u1834\u0007\u008c\u0002\u0002", + "\u1834\u1835\u0007\u00fc\u0002\u0002\u1835\u1836\u0007\u0171\u0002\u0002", + "\u1836\u1837\u0005\u052e\u0298\u0002\u1837\u1838\u0007\u012e\u0002\u0002", + "\u1838\u1839\u0005\u02d6\u016c\u0002\u1839\u183a\u0005\u0532\u029a\u0002", + "\u183a\u183b\u0007`\u0002\u0002\u183b\u183c\u0005\u0532\u029a\u0002", + "\u183c\u18df\u0003\u0002\u0002\u0002\u183d\u183e\u0007\u008c\u0002\u0002", + "\u183e\u183f\u0007\u00fc\u0002\u0002\u183f\u1840\u0007\u0171\u0002\u0002", + "\u1840\u1841\u0007\u00de\u0002\u0002\u1841\u1842\u0007\u0185\u0002\u0002", + "\u1842\u1843\u0005\u052e\u0298\u0002\u1843\u1844\u0007\u012e\u0002\u0002", + "\u1844\u1845\u0005\u02d6\u016c\u0002\u1845\u1846\u0005\u0532\u029a\u0002", + "\u1846\u1847\u0007`\u0002\u0002\u1847\u1848\u0005\u0532\u029a\u0002", + "\u1848\u18df\u0003\u0002\u0002\u0002\u1849\u184a\u0007\u008c\u0002\u0002", + "\u184a\u184b\u0007^\u0002\u0002\u184b\u184c\u0005\u042a\u0216\u0002", + "\u184c\u184d\u0007\u012e\u0002\u0002\u184d\u184e\u0007/\u0002\u0002", + "\u184e\u184f\u0005\u0532\u029a\u0002\u184f\u1850\u0007`\u0002\u0002", + "\u1850\u1851\u0005\u0532\u029a\u0002\u1851\u18df\u0003\u0002\u0002\u0002", + "\u1852\u1853\u0007\u008c\u0002\u0002\u1853\u1854\u0007^\u0002\u0002", + "\u1854\u1855\u0007\u00de\u0002\u0002\u1855\u1856\u0007\u0185\u0002\u0002", + "\u1856\u1857\u0005\u042a\u0216\u0002\u1857\u1858\u0007\u012e\u0002\u0002", + "\u1858\u1859\u0007/\u0002\u0002\u1859\u185a\u0005\u0532\u029a\u0002", + "\u185a\u185b\u0007`\u0002\u0002\u185b\u185c\u0005\u0532\u029a\u0002", + "\u185c\u18df\u0003\u0002\u0002\u0002\u185d\u185e\u0007\u008c\u0002\u0002", + "\u185e\u185f\u0007A\u0002\u0002\u185f\u1860\u0007^\u0002\u0002\u1860", + "\u1861\u0005\u042a\u0216\u0002\u1861\u1862\u0007\u012e\u0002\u0002\u1862", + "\u1863\u0005\u02d6\u016c\u0002\u1863\u1864\u0005\u0532\u029a\u0002\u1864", + "\u1865\u0007`\u0002\u0002\u1865\u1866\u0005\u0532\u029a\u0002\u1866", + "\u18df\u0003\u0002\u0002\u0002\u1867\u1868\u0007\u008c\u0002\u0002\u1868", + "\u1869\u0007A\u0002\u0002\u1869\u186a\u0007^\u0002\u0002\u186a\u186b", + "\u0007\u00de\u0002\u0002\u186b\u186c\u0007\u0185\u0002\u0002\u186c\u186d", + "\u0005\u042a\u0216\u0002\u186d\u186e\u0007\u012e\u0002\u0002\u186e\u186f", + "\u0005\u02d6\u016c\u0002\u186f\u1870\u0005\u0532\u029a\u0002\u1870\u1871", + "\u0007`\u0002\u0002\u1871\u1872\u0005\u0532\u029a\u0002\u1872\u18df", + "\u0003\u0002\u0002\u0002\u1873\u1874\u0007\u008c\u0002\u0002\u1874\u1875", + "\u0007\u013a\u0002\u0002\u1875\u1876\u0005\u0532\u029a\u0002\u1876\u1877", + "\u0007R\u0002\u0002\u1877\u1878\u0005\u052e\u0298\u0002\u1878\u1879", + "\u0007\u012e\u0002\u0002\u1879\u187a\u0007`\u0002\u0002\u187a\u187b", + "\u0005\u0532\u029a\u0002\u187b\u18df\u0003\u0002\u0002\u0002\u187c\u187d", + "\u0007\u008c\u0002\u0002\u187d\u187e\u0007\u015e\u0002\u0002\u187e\u187f", + "\u0005\u0532\u029a\u0002\u187f\u1880\u0007R\u0002\u0002\u1880\u1881", + "\u0005\u052e\u0298\u0002\u1881\u1882\u0007\u012e\u0002\u0002\u1882\u1883", + "\u0007`\u0002\u0002\u1883\u1884\u0005\u0532\u029a\u0002\u1884\u18df", + "\u0003\u0002\u0002\u0002\u1885\u1886\u0007\u008c\u0002\u0002\u1886\u1887", + "\u0007\u00c8\u0002\u0002\u1887\u1888\u0007\u015e\u0002\u0002\u1888\u1889", + "\u0005\u0532\u029a\u0002\u1889\u188a\u0007\u012e\u0002\u0002\u188a\u188b", + "\u0007`\u0002\u0002\u188b\u188c\u0005\u0532\u029a\u0002\u188c\u18df", + "\u0003\u0002\u0002\u0002\u188d\u188e\u0007\u008c\u0002\u0002\u188e\u188f", + "\u0007\u0137\u0002\u0002\u188f\u1890\u0005\u054c\u02a7\u0002\u1890\u1891", + "\u0007\u012e\u0002\u0002\u1891\u1892\u0007`\u0002\u0002\u1892\u1893", + "\u0005\u054c\u02a7\u0002\u1893\u18df\u0003\u0002\u0002\u0002\u1894\u1895", + "\u0007\u008c\u0002\u0002\u1895\u1896\u0007e\u0002\u0002\u1896\u1897", + "\u0005\u054c\u02a7\u0002\u1897\u1898\u0007\u012e\u0002\u0002\u1898\u1899", + "\u0007`\u0002\u0002\u1899\u189a\u0005\u054c\u02a7\u0002\u189a\u18df", + "\u0003\u0002\u0002\u0002\u189b\u189c\u0007\u008c\u0002\u0002\u189c\u189d", + "\u0007\u0158\u0002\u0002\u189d\u189e\u0005\u0532\u029a\u0002\u189e\u189f", + "\u0007\u012e\u0002\u0002\u189f\u18a0\u0007`\u0002\u0002\u18a0\u18a1", + "\u0005\u0532\u029a\u0002\u18a1\u18df\u0003\u0002\u0002\u0002\u18a2\u18a3", + "\u0007\u008c\u0002\u0002\u18a3\u18a4\u0007\u014f\u0002\u0002\u18a4\u18a5", + "\u0005\u020e\u0108\u0002\u18a5\u18a6\u0007\u012e\u0002\u0002\u18a6\u18a7", + "\u0007`\u0002\u0002\u18a7\u18a8\u0005\u0532\u029a\u0002\u18a8\u18df", + "\u0003\u0002\u0002\u0002\u18a9\u18aa\u0007\u008c\u0002\u0002\u18aa\u18ab", + "\u0007\u015c\u0002\u0002\u18ab\u18ac\u0007\u013e\u0002\u0002\u18ac\u18ad", + "\u0007\u0114\u0002\u0002\u18ad\u18ae\u0005\u020e\u0108\u0002\u18ae\u18af", + "\u0007\u012e\u0002\u0002\u18af\u18b0\u0007`\u0002\u0002\u18b0\u18b1", + "\u0005\u0532\u029a\u0002\u18b1\u18df\u0003\u0002\u0002\u0002\u18b2\u18b3", + "\u0007\u008c\u0002\u0002\u18b3\u18b4\u0007\u015c\u0002\u0002\u18b4\u18b5", + "\u0007\u013e\u0002\u0002\u18b5\u18b6\u0007\u00bb\u0002\u0002\u18b6\u18b7", + "\u0005\u020e\u0108\u0002\u18b7\u18b8\u0007\u012e\u0002\u0002\u18b8\u18b9", + "\u0007`\u0002\u0002\u18b9\u18ba\u0005\u0532\u029a\u0002\u18ba\u18df", + "\u0003\u0002\u0002\u0002\u18bb\u18bc\u0007\u008c\u0002\u0002\u18bc\u18bd", + "\u0007\u015c\u0002\u0002\u18bd\u18be\u0007\u013e\u0002\u0002\u18be\u18bf", + "\u0007\u015a\u0002\u0002\u18bf\u18c0\u0005\u020e\u0108\u0002\u18c0\u18c1", + "\u0007\u012e\u0002\u0002\u18c1\u18c2\u0007`\u0002\u0002\u18c2\u18c3", + "\u0005\u0532\u029a\u0002\u18c3\u18df\u0003\u0002\u0002\u0002\u18c4\u18c5", + "\u0007\u008c\u0002\u0002\u18c5\u18c6\u0007\u015c\u0002\u0002\u18c6\u18c7", + "\u0007\u013e\u0002\u0002\u18c7\u18c8\u0007\u00a5\u0002\u0002\u18c8\u18c9", + "\u0005\u020e\u0108\u0002\u18c9\u18ca\u0007\u012e\u0002\u0002\u18ca\u18cb", + "\u0007`\u0002\u0002\u18cb\u18cc\u0005\u0532\u029a\u0002\u18cc\u18df", + "\u0003\u0002\u0002\u0002\u18cd\u18ce\u0007\u008c\u0002\u0002\u18ce\u18cf", + "\u0007\u0161\u0002\u0002\u18cf\u18d0\u0005\u020e\u0108\u0002\u18d0\u18d1", + "\u0007\u012e\u0002\u0002\u18d1\u18d2\u0007`\u0002\u0002\u18d2\u18d3", + "\u0005\u0532\u029a\u0002\u18d3\u18df\u0003\u0002\u0002\u0002\u18d4\u18d5", + "\u0007\u008c\u0002\u0002\u18d5\u18d6\u0007\u0161\u0002\u0002\u18d6\u18d7", + "\u0005\u020e\u0108\u0002\u18d7\u18d8\u0007\u012e\u0002\u0002\u18d8\u18d9", + "\u0007\u0091\u0002\u0002\u18d9\u18da\u0005\u0532\u029a\u0002\u18da\u18db", + "\u0007`\u0002\u0002\u18db\u18dc\u0005\u0532\u029a\u0002\u18dc\u18dd", + "\u0005n8\u0002\u18dd\u18df\u0003\u0002\u0002\u0002\u18de\u170a\u0003", + "\u0002\u0002\u0002\u18de\u1711\u0003\u0002\u0002\u0002\u18de\u1718\u0003", + "\u0002\u0002\u0002\u18de\u171f\u0003\u0002\u0002\u0002\u18de\u1726\u0003", + "\u0002\u0002\u0002\u18de\u172d\u0003\u0002\u0002\u0002\u18de\u1736\u0003", + "\u0002\u0002\u0002\u18de\u173f\u0003\u0002\u0002\u0002\u18de\u1746\u0003", + "\u0002\u0002\u0002\u18de\u174d\u0003\u0002\u0002\u0002\u18de\u1755\u0003", + "\u0002\u0002\u0002\u18de\u175f\u0003\u0002\u0002\u0002\u18de\u1769\u0003", + "\u0002\u0002\u0002\u18de\u1772\u0003\u0002\u0002\u0002\u18de\u177d\u0003", + "\u0002\u0002\u0002\u18de\u1784\u0003\u0002\u0002\u0002\u18de\u178b\u0003", + "\u0002\u0002\u0002\u18de\u1792\u0003\u0002\u0002\u0002\u18de\u1799\u0003", + "\u0002\u0002\u0002\u18de\u17a0\u0003\u0002\u0002\u0002\u18de\u17a7\u0003", + "\u0002\u0002\u0002\u18de\u17ae\u0003\u0002\u0002\u0002\u18de\u17b7\u0003", + "\u0002\u0002\u0002\u18de\u17be\u0003\u0002\u0002\u0002\u18de\u17c7\u0003", + "\u0002\u0002\u0002\u18de\u17ce\u0003\u0002\u0002\u0002\u18de\u17d7\u0003", + "\u0002\u0002\u0002\u18de\u17df\u0003\u0002\u0002\u0002\u18de\u17e9\u0003", + "\u0002\u0002\u0002\u18de\u17f0\u0003\u0002\u0002\u0002\u18de\u17f9\u0003", + "\u0002\u0002\u0002\u18de\u1801\u0003\u0002\u0002\u0002\u18de\u180b\u0003", + "\u0002\u0002\u0002\u18de\u1814\u0003\u0002\u0002\u0002\u18de\u181f\u0003", + "\u0002\u0002\u0002\u18de\u1828\u0003\u0002\u0002\u0002\u18de\u1833\u0003", + "\u0002\u0002\u0002\u18de\u183d\u0003\u0002\u0002\u0002\u18de\u1849\u0003", + "\u0002\u0002\u0002\u18de\u1852\u0003\u0002\u0002\u0002\u18de\u185d\u0003", + "\u0002\u0002\u0002\u18de\u1867\u0003\u0002\u0002\u0002\u18de\u1873\u0003", + "\u0002\u0002\u0002\u18de\u187c\u0003\u0002\u0002\u0002\u18de\u1885\u0003", + "\u0002\u0002\u0002\u18de\u188d\u0003\u0002\u0002\u0002\u18de\u1894\u0003", + "\u0002\u0002\u0002\u18de\u189b\u0003\u0002\u0002\u0002\u18de\u18a2\u0003", + "\u0002\u0002\u0002\u18de\u18a9\u0003\u0002\u0002\u0002\u18de\u18b2\u0003", + "\u0002\u0002\u0002\u18de\u18bb\u0003\u0002\u0002\u0002\u18de\u18c4\u0003", + "\u0002\u0002\u0002\u18de\u18cd\u0003\u0002\u0002\u0002\u18de\u18d4\u0003", + "\u0002\u0002\u0002\u18df\u02d5\u0003\u0002\u0002\u0002\u18e0\u18e3\u0007", + ".\u0002\u0002\u18e1\u18e3\u0003\u0002\u0002\u0002\u18e2\u18e0\u0003", + "\u0002\u0002\u0002\u18e2\u18e1\u0003\u0002\u0002\u0002\u18e3\u02d7\u0003", + "\u0002\u0002\u0002\u18e4\u18e5\u0007\u0146\u0002\u0002\u18e5\u18e8\u0007", + "\u00b0\u0002\u0002\u18e6\u18e8\u0003\u0002\u0002\u0002\u18e7\u18e4\u0003", + "\u0002\u0002\u0002\u18e7\u18e6\u0003\u0002\u0002\u0002\u18e8\u02d9\u0003", + "\u0002\u0002\u0002\u18e9\u18ea\u0007\u008c\u0002\u0002\u18ea\u18eb\u0007", + "\u00d5\u0002\u0002\u18eb\u18ec\u0005\u0274\u013b\u0002\u18ec\u18ed\u0005", + "\u02dc\u016f\u0002\u18ed\u18ee\u0007\u01c7\u0002\u0002\u18ee\u18ef\u0007", + "R\u0002\u0002\u18ef\u18f0\u0007\u00ce\u0002\u0002\u18f0\u18f1\u0005", + "\u0532\u029a\u0002\u18f1\u1923\u0003\u0002\u0002\u0002\u18f2\u18f3\u0007", + "\u008c\u0002\u0002\u18f3\u18f4\u0007\u0121\u0002\u0002\u18f4\u18f5\u0005", + "\u0274\u013b\u0002\u18f5\u18f6\u0005\u02dc\u016f\u0002\u18f6\u18f7\u0007", + "\u01c7\u0002\u0002\u18f7\u18f8\u0007R\u0002\u0002\u18f8\u18f9\u0007", + "\u00ce\u0002\u0002\u18f9\u18fa\u0005\u0532\u029a\u0002\u18fa\u1923\u0003", + "\u0002\u0002\u0002\u18fb\u18fc\u0007\u008c\u0002\u0002\u18fc\u18fd\u0007", + "\u01b3\u0002\u0002\u18fd\u18fe\u0005\u0274\u013b\u0002\u18fe\u18ff\u0005", + "\u02dc\u016f\u0002\u18ff\u1900\u0007\u01c7\u0002\u0002\u1900\u1901\u0007", + "R\u0002\u0002\u1901\u1902\u0007\u00ce\u0002\u0002\u1902\u1903\u0005", + "\u0532\u029a\u0002\u1903\u1923\u0003\u0002\u0002\u0002\u1904\u1905\u0007", + "\u008c\u0002\u0002\u1905\u1906\u0007\u015e\u0002\u0002\u1906\u1907\u0005", + "\u0532\u029a\u0002\u1907\u1908\u0007R\u0002\u0002\u1908\u1909\u0005", + "\u052e\u0298\u0002\u1909\u190a\u0005\u02dc\u016f\u0002\u190a\u190b\u0007", + "\u01c7\u0002\u0002\u190b\u190c\u0007R\u0002\u0002\u190c\u190d\u0007", + "\u00ce\u0002\u0002\u190d\u190e\u0005\u0532\u029a\u0002\u190e\u1923\u0003", + "\u0002\u0002\u0002\u190f\u1910\u0007\u008c\u0002\u0002\u1910\u1911\u0007", + "\u00fc\u0002\u0002\u1911\u1912\u0007\u0171\u0002\u0002\u1912\u1913\u0005", + "\u052e\u0298\u0002\u1913\u1914\u0005\u02dc\u016f\u0002\u1914\u1915\u0007", + "\u01c7\u0002\u0002\u1915\u1916\u0007R\u0002\u0002\u1916\u1917\u0007", + "\u00ce\u0002\u0002\u1917\u1918\u0005\u0532\u029a\u0002\u1918\u1923\u0003", + "\u0002\u0002\u0002\u1919\u191a\u0007\u008c\u0002\u0002\u191a\u191b\u0007", + "\u00e4\u0002\u0002\u191b\u191c\u0005\u052e\u0298\u0002\u191c\u191d\u0005", + "\u02dc\u016f\u0002\u191d\u191e\u0007\u01c7\u0002\u0002\u191e\u191f\u0007", + "R\u0002\u0002\u191f\u1920\u0007\u00ce\u0002\u0002\u1920\u1921\u0005", + "\u0532\u029a\u0002\u1921\u1923\u0003\u0002\u0002\u0002\u1922\u18e9\u0003", + "\u0002\u0002\u0002\u1922\u18f2\u0003\u0002\u0002\u0002\u1922\u18fb\u0003", + "\u0002\u0002\u0002\u1922\u1904\u0003\u0002\u0002\u0002\u1922\u190f\u0003", + "\u0002\u0002\u0002\u1922\u1919\u0003\u0002\u0002\u0002\u1923\u02db\u0003", + "\u0002\u0002\u0002\u1924\u1927\u0007\u0106\u0002\u0002\u1925\u1927\u0003", + "\u0002\u0002\u0002\u1926\u1924\u0003\u0002\u0002\u0002\u1926\u1925\u0003", + "\u0002\u0002\u0002\u1927\u02dd\u0003\u0002\u0002\u0002\u1928\u1929\u0007", + "\u008c\u0002\u0002\u1929\u192a\u0007\u008a\u0002\u0002\u192a\u192b\u0005", + "\u028c\u0147\u0002\u192b\u192c\u0007\u0146\u0002\u0002\u192c\u192d\u0007", + "\u013c\u0002\u0002\u192d\u192e\u0005\u0532\u029a\u0002\u192e\u1a02\u0003", + "\u0002\u0002\u0002\u192f\u1930\u0007\u008c\u0002\u0002\u1930\u1931\u0007", + "n\u0002\u0002\u1931\u1932\u0005\u020e\u0108\u0002\u1932\u1933\u0007", + "\u0146\u0002\u0002\u1933\u1934\u0007\u013c\u0002\u0002\u1934\u1935\u0005", + "\u0532\u029a\u0002\u1935\u1a02\u0003\u0002\u0002\u0002\u1936\u1937\u0007", + "\u008c\u0002\u0002\u1937\u1938\u0007\u00aa\u0002\u0002\u1938\u1939\u0005", + "\u020e\u0108\u0002\u1939\u193a\u0007\u0146\u0002\u0002\u193a\u193b\u0007", + "\u013c\u0002\u0002\u193b\u193c\u0005\u0532\u029a\u0002\u193c\u1a02\u0003", + "\u0002\u0002\u0002\u193d\u193e\u0007\u008c\u0002\u0002\u193e\u193f\u0007", + "\u00bf\u0002\u0002\u193f\u1940\u0005\u020e\u0108\u0002\u1940\u1941\u0007", + "\u0146\u0002\u0002\u1941\u1942\u0007\u013c\u0002\u0002\u1942\u1943\u0005", + "\u0532\u029a\u0002\u1943\u1a02\u0003\u0002\u0002\u0002\u1944\u1945\u0007", + "\u008c\u0002\u0002\u1945\u1946\u0007\u00ce\u0002\u0002\u1946\u1947\u0005", + "\u0532\u029a\u0002\u1947\u1948\u0007\u0146\u0002\u0002\u1948\u1949\u0007", + "\u013c\u0002\u0002\u1949\u194a\u0005\u0532\u029a\u0002\u194a\u1a02\u0003", + "\u0002\u0002\u0002\u194b\u194c\u0007\u008c\u0002\u0002\u194c\u194d\u0007", + "\u00d5\u0002\u0002\u194d\u194e\u0005\u0274\u013b\u0002\u194e\u194f\u0007", + "\u0146\u0002\u0002\u194f\u1950\u0007\u013c\u0002\u0002\u1950\u1951\u0005", + "\u0532\u029a\u0002\u1951\u1a02\u0003\u0002\u0002\u0002\u1952\u1953\u0007", + "\u008c\u0002\u0002\u1953\u1954\u0007\u010f\u0002\u0002\u1954\u1955\u0005", + "\u02b2\u015a\u0002\u1955\u1956\u0007\u0146\u0002\u0002\u1956\u1957\u0007", + "\u013c\u0002\u0002\u1957\u1958\u0005\u0532\u029a\u0002\u1958\u1a02\u0003", + "\u0002\u0002\u0002\u1959\u195a\u0007\u008c\u0002\u0002\u195a\u195b\u0007", + "\u010f\u0002\u0002\u195b\u195c\u0007\u009e\u0002\u0002\u195c\u195d\u0005", + "\u020e\u0108\u0002\u195d\u195e\u0007f\u0002\u0002\u195e\u195f\u0005", + "\u0532\u029a\u0002\u195f\u1960\u0007\u0146\u0002\u0002\u1960\u1961\u0007", + "\u013c\u0002\u0002\u1961\u1962\u0005\u0532\u029a\u0002\u1962\u1a02\u0003", + "\u0002\u0002\u0002\u1963\u1964\u0007\u008c\u0002\u0002\u1964\u1965\u0007", + "\u010f\u0002\u0002\u1965\u1966\u0007\u00d0\u0002\u0002\u1966\u1967\u0005", + "\u020e\u0108\u0002\u1967\u1968\u0007f\u0002\u0002\u1968\u1969\u0005", + "\u0532\u029a\u0002\u1969\u196a\u0007\u0146\u0002\u0002\u196a\u196b\u0007", + "\u013c\u0002\u0002\u196b\u196c\u0005\u0532\u029a\u0002\u196c\u1a02\u0003", + "\u0002\u0002\u0002\u196d\u196e\u0007\u008c\u0002\u0002\u196e\u196f\u0007", + "\u0121\u0002\u0002\u196f\u1970\u0005\u0274\u013b\u0002\u1970\u1971\u0007", + "\u0146\u0002\u0002\u1971\u1972\u0007\u013c\u0002\u0002\u1972\u1973\u0005", + "\u0532\u029a\u0002\u1973\u1a02\u0003\u0002\u0002\u0002\u1974\u1975\u0007", + "\u008c\u0002\u0002\u1975\u1976\u0007\u01b3\u0002\u0002\u1976\u1977\u0005", + "\u0274\u013b\u0002\u1977\u1978\u0007\u0146\u0002\u0002\u1978\u1979\u0007", + "\u013c\u0002\u0002\u1979\u197a\u0005\u0532\u029a\u0002\u197a\u1a02\u0003", + "\u0002\u0002\u0002\u197b\u197c\u0007\u008c\u0002\u0002\u197c\u197d\u0007", + "^\u0002\u0002\u197d\u197e\u0005\u042a\u0216\u0002\u197e\u197f\u0007", + "\u0146\u0002\u0002\u197f\u1980\u0007\u013c\u0002\u0002\u1980\u1981\u0005", + "\u0532\u029a\u0002\u1981\u1a02\u0003\u0002\u0002\u0002\u1982\u1983\u0007", + "\u008c\u0002\u0002\u1983\u1984\u0007^\u0002\u0002\u1984\u1985\u0007", + "\u00de\u0002\u0002\u1985\u1986\u0007\u0185\u0002\u0002\u1986\u1987\u0005", + "\u042a\u0216\u0002\u1987\u1988\u0007\u0146\u0002\u0002\u1988\u1989\u0007", + "\u013c\u0002\u0002\u1989\u198a\u0005\u0532\u029a\u0002\u198a\u1a02\u0003", + "\u0002\u0002\u0002\u198b\u198c\u0007\u008c\u0002\u0002\u198c\u198d\u0007", + "\u014f\u0002\u0002\u198d\u198e\u0005\u020e\u0108\u0002\u198e\u198f\u0007", + "\u0146\u0002\u0002\u198f\u1990\u0007\u013c\u0002\u0002\u1990\u1991\u0005", + "\u0532\u029a\u0002\u1991\u1a02\u0003\u0002\u0002\u0002\u1992\u1993\u0007", + "\u008c\u0002\u0002\u1993\u1994\u0007\u015c\u0002\u0002\u1994\u1995\u0007", + "\u013e\u0002\u0002\u1995\u1996\u0007\u0114\u0002\u0002\u1996\u1997\u0005", + "\u020e\u0108\u0002\u1997\u1998\u0007\u0146\u0002\u0002\u1998\u1999\u0007", + "\u013c\u0002\u0002\u1999\u199a\u0005\u0532\u029a\u0002\u199a\u1a02\u0003", + "\u0002\u0002\u0002\u199b\u199c\u0007\u008c\u0002\u0002\u199c\u199d\u0007", + "\u015c\u0002\u0002\u199d\u199e\u0007\u013e\u0002\u0002\u199e\u199f\u0007", + "\u00bb\u0002\u0002\u199f\u19a0\u0005\u020e\u0108\u0002\u19a0\u19a1\u0007", + "\u0146\u0002\u0002\u19a1\u19a2\u0007\u013c\u0002\u0002\u19a2\u19a3\u0005", + "\u0532\u029a\u0002\u19a3\u1a02\u0003\u0002\u0002\u0002\u19a4\u19a5\u0007", + "\u008c\u0002\u0002\u19a5\u19a6\u0007\u015c\u0002\u0002\u19a6\u19a7\u0007", + "\u013e\u0002\u0002\u19a7\u19a8\u0007\u015a\u0002\u0002\u19a8\u19a9\u0005", + "\u020e\u0108\u0002\u19a9\u19aa\u0007\u0146\u0002\u0002\u19aa\u19ab\u0007", + "\u013c\u0002\u0002\u19ab\u19ac\u0005\u0532\u029a\u0002\u19ac\u1a02\u0003", + "\u0002\u0002\u0002\u19ad\u19ae\u0007\u008c\u0002\u0002\u19ae\u19af\u0007", + "\u015c\u0002\u0002\u19af\u19b0\u0007\u013e\u0002\u0002\u19b0\u19b1\u0007", + "\u00a5\u0002\u0002\u19b1\u19b2\u0005\u020e\u0108\u0002\u19b2\u19b3\u0007", + "\u0146\u0002\u0002\u19b3\u19b4\u0007\u013c\u0002\u0002\u19b4\u19b5\u0005", + "\u0532\u029a\u0002\u19b5\u1a02\u0003\u0002\u0002\u0002\u19b6\u19b7\u0007", + "\u008c\u0002\u0002\u19b7\u19b8\u0007\u0141\u0002\u0002\u19b8\u19b9\u0005", + "\u052e\u0298\u0002\u19b9\u19ba\u0007\u0146\u0002\u0002\u19ba\u19bb\u0007", + "\u013c\u0002\u0002\u19bb\u19bc\u0005\u0532\u029a\u0002\u19bc\u1a02\u0003", + "\u0002\u0002\u0002\u19bd\u19be\u0007\u008c\u0002\u0002\u19be\u19bf\u0007", + "\u0141\u0002\u0002\u19bf\u19c0\u0007\u00de\u0002\u0002\u19c0\u19c1\u0007", + "\u0185\u0002\u0002\u19c1\u19c2\u0005\u052e\u0298\u0002\u19c2\u19c3\u0007", + "\u0146\u0002\u0002\u19c3\u19c4\u0007\u013c\u0002\u0002\u19c4\u19c5\u0005", + "\u0532\u029a\u0002\u19c5\u1a02\u0003\u0002\u0002\u0002\u19c6\u19c7\u0007", + "\u008c\u0002\u0002\u19c7\u19c8\u0007\u0171\u0002\u0002\u19c8\u19c9\u0005", + "\u052e\u0298\u0002\u19c9\u19ca\u0007\u0146\u0002\u0002\u19ca\u19cb\u0007", + "\u013c\u0002\u0002\u19cb\u19cc\u0005\u0532\u029a\u0002\u19cc\u1a02\u0003", + "\u0002\u0002\u0002\u19cd\u19ce\u0007\u008c\u0002\u0002\u19ce\u19cf\u0007", + "\u0171\u0002\u0002\u19cf\u19d0\u0007\u00de\u0002\u0002\u19d0\u19d1\u0007", + "\u0185\u0002\u0002\u19d1\u19d2\u0005\u052e\u0298\u0002\u19d2\u19d3\u0007", + "\u0146\u0002\u0002\u19d3\u19d4\u0007\u013c\u0002\u0002\u19d4\u19d5\u0005", + "\u0532\u029a\u0002\u19d5\u1a02\u0003\u0002\u0002\u0002\u19d6\u19d7\u0007", + "\u008c\u0002\u0002\u19d7\u19d8\u0007\u00fc\u0002\u0002\u19d8\u19d9\u0007", + "\u0171\u0002\u0002\u19d9\u19da\u0005\u052e\u0298\u0002\u19da\u19db\u0007", + "\u0146\u0002\u0002\u19db\u19dc\u0007\u013c\u0002\u0002\u19dc\u19dd\u0005", + "\u0532\u029a\u0002\u19dd\u1a02\u0003\u0002\u0002\u0002\u19de\u19df\u0007", + "\u008c\u0002\u0002\u19df\u19e0\u0007\u00fc\u0002\u0002\u19e0\u19e1\u0007", + "\u0171\u0002\u0002\u19e1\u19e2\u0007\u00de\u0002\u0002\u19e2\u19e3\u0007", + "\u0185\u0002\u0002\u19e3\u19e4\u0005\u052e\u0298\u0002\u19e4\u19e5\u0007", + "\u0146\u0002\u0002\u19e5\u19e6\u0007\u013c\u0002\u0002\u19e6\u19e7\u0005", + "\u0532\u029a\u0002\u19e7\u1a02\u0003\u0002\u0002\u0002\u19e8\u19e9\u0007", + "\u008c\u0002\u0002\u19e9\u19ea\u0007A\u0002\u0002\u19ea\u19eb\u0007", + "^\u0002\u0002\u19eb\u19ec\u0005\u042a\u0216\u0002\u19ec\u19ed\u0007", + "\u0146\u0002\u0002\u19ed\u19ee\u0007\u013c\u0002\u0002\u19ee\u19ef\u0005", + "\u0532\u029a\u0002\u19ef\u1a02\u0003\u0002\u0002\u0002\u19f0\u19f1\u0007", + "\u008c\u0002\u0002\u19f1\u19f2\u0007A\u0002\u0002\u19f2\u19f3\u0007", + "^\u0002\u0002\u19f3\u19f4\u0007\u00de\u0002\u0002\u19f4\u19f5\u0007", + "\u0185\u0002\u0002\u19f5\u19f6\u0005\u042a\u0216\u0002\u19f6\u19f7\u0007", + "\u0146\u0002\u0002\u19f7\u19f8\u0007\u013c\u0002\u0002\u19f8\u19f9\u0005", + "\u0532\u029a\u0002\u19f9\u1a02\u0003\u0002\u0002\u0002\u19fa\u19fb\u0007", + "\u008c\u0002\u0002\u19fb\u19fc\u0007\u0161\u0002\u0002\u19fc\u19fd\u0005", + "\u020e\u0108\u0002\u19fd\u19fe\u0007\u0146\u0002\u0002\u19fe\u19ff\u0007", + "\u013c\u0002\u0002\u19ff\u1a00\u0005\u0532\u029a\u0002\u1a00\u1a02\u0003", + "\u0002\u0002\u0002\u1a01\u1928\u0003\u0002\u0002\u0002\u1a01\u192f\u0003", + "\u0002\u0002\u0002\u1a01\u1936\u0003\u0002\u0002\u0002\u1a01\u193d\u0003", + "\u0002\u0002\u0002\u1a01\u1944\u0003\u0002\u0002\u0002\u1a01\u194b\u0003", + "\u0002\u0002\u0002\u1a01\u1952\u0003\u0002\u0002\u0002\u1a01\u1959\u0003", + "\u0002\u0002\u0002\u1a01\u1963\u0003\u0002\u0002\u0002\u1a01\u196d\u0003", + "\u0002\u0002\u0002\u1a01\u1974\u0003\u0002\u0002\u0002\u1a01\u197b\u0003", + "\u0002\u0002\u0002\u1a01\u1982\u0003\u0002\u0002\u0002\u1a01\u198b\u0003", + "\u0002\u0002\u0002\u1a01\u1992\u0003\u0002\u0002\u0002\u1a01\u199b\u0003", + "\u0002\u0002\u0002\u1a01\u19a4\u0003\u0002\u0002\u0002\u1a01\u19ad\u0003", + "\u0002\u0002\u0002\u1a01\u19b6\u0003\u0002\u0002\u0002\u1a01\u19bd\u0003", + "\u0002\u0002\u0002\u1a01\u19c6\u0003\u0002\u0002\u0002\u1a01\u19cd\u0003", + "\u0002\u0002\u0002\u1a01\u19d6\u0003\u0002\u0002\u0002\u1a01\u19de\u0003", + "\u0002\u0002\u0002\u1a01\u19e8\u0003\u0002\u0002\u0002\u1a01\u19f0\u0003", + "\u0002\u0002\u0002\u1a01\u19fa\u0003\u0002\u0002\u0002\u1a02\u02df\u0003", + "\u0002\u0002\u0002\u1a03\u1a04\u0007\u008c\u0002\u0002\u1a04\u1a05\u0007", + "\u010f\u0002\u0002\u1a05\u1a06\u0005\u02b2\u015a\u0002\u1a06\u1a07\u0007", + "\u0146\u0002\u0002\u1a07\u1a08\u0007\u0004\u0002\u0002\u1a08\u1a09\u0005", + "\u02e2\u0172\u0002\u1a09\u1a0a\u0007\u0005\u0002\u0002\u1a0a\u02e1\u0003", + "\u0002\u0002\u0002\u1a0b\u1a10\u0005\u02e4\u0173\u0002\u1a0c\u1a0d\u0007", + "\b\u0002\u0002\u1a0d\u1a0f\u0005\u02e4\u0173\u0002\u1a0e\u1a0c\u0003", + "\u0002\u0002\u0002\u1a0f\u1a12\u0003\u0002\u0002\u0002\u1a10\u1a0e\u0003", + "\u0002\u0002\u0002\u1a10\u1a11\u0003\u0002\u0002\u0002\u1a11\u02e3\u0003", + "\u0002\u0002\u0002\u1a12\u1a10\u0003\u0002\u0002\u0002\u1a13\u1a14\u0005", + "\u0558\u02ad\u0002\u1a14\u1a15\u0007\f\u0002\u0002\u1a15\u1a16\u0007", + "\u0190\u0002\u0002\u1a16\u1a1c\u0003\u0002\u0002\u0002\u1a17\u1a18\u0005", + "\u0558\u02ad\u0002\u1a18\u1a19\u0007\f\u0002\u0002\u1a19\u1a1a\u0005", + "\u02e6\u0174\u0002\u1a1a\u1a1c\u0003\u0002\u0002\u0002\u1a1b\u1a13\u0003", + "\u0002\u0002\u0002\u1a1b\u1a17\u0003\u0002\u0002\u0002\u1a1c\u02e5\u0003", + "\u0002\u0002\u0002\u1a1d\u1a23\u0005\u0282\u0142\u0002\u1a1e\u1a23\u0005", + "\u0564\u02b3\u0002\u1a1f\u1a23\u0005\u04f2\u027a\u0002\u1a20\u1a23\u0005", + "\u0126\u0094\u0002\u1a21\u1a23\u0005\u0544\u02a3\u0002\u1a22\u1a1d\u0003", + "\u0002\u0002\u0002\u1a22\u1a1e\u0003\u0002\u0002\u0002\u1a22\u1a1f\u0003", + "\u0002\u0002\u0002\u1a22\u1a20\u0003\u0002\u0002\u0002\u1a22\u1a21\u0003", + "\u0002\u0002\u0002\u1a23\u02e7\u0003\u0002\u0002\u0002\u1a24\u1a25\u0007", + "\u008c\u0002\u0002\u1a25\u1a26\u0007\u0161\u0002\u0002\u1a26\u1a27\u0005", + "\u020e\u0108\u0002\u1a27\u1a28\u0007\u0146\u0002\u0002\u1a28\u1a29\u0007", + "\u0004\u0002\u0002\u1a29\u1a2a\u0005\u02e2\u0172\u0002\u1a2a\u1a2b\u0007", + "\u0005\u0002\u0002\u1a2b\u02e9\u0003\u0002\u0002\u0002\u1a2c\u1a2d\u0007", + "\u008c\u0002\u0002\u1a2d\u1a2e\u0007\u008a\u0002\u0002\u1a2e\u1a2f\u0005", + "\u028c\u0147\u0002\u1a2f\u1a30\u0007\u0113\u0002\u0002\u1a30\u1a31\u0007", + "`\u0002\u0002\u1a31\u1a32\u0005\u054e\u02a8\u0002\u1a32\u1ae4\u0003", + "\u0002\u0002\u0002\u1a33\u1a34\u0007\u008c\u0002\u0002\u1a34\u1a35\u0007", + "n\u0002\u0002\u1a35\u1a36\u0005\u020e\u0108\u0002\u1a36\u1a37\u0007", + "\u0113\u0002\u0002\u1a37\u1a38\u0007`\u0002\u0002\u1a38\u1a39\u0005", + "\u054e\u02a8\u0002\u1a39\u1ae4\u0003\u0002\u0002\u0002\u1a3a\u1a3b\u0007", + "\u008c\u0002\u0002\u1a3b\u1a3c\u0007\u00aa\u0002\u0002\u1a3c\u1a3d\u0005", + "\u020e\u0108\u0002\u1a3d\u1a3e\u0007\u0113\u0002\u0002\u1a3e\u1a3f\u0007", + "`\u0002\u0002\u1a3f\u1a40\u0005\u054e\u02a8\u0002\u1a40\u1ae4\u0003", + "\u0002\u0002\u0002\u1a41\u1a42\u0007\u008c\u0002\u0002\u1a42\u1a43\u0007", + "\u00b1\u0002\u0002\u1a43\u1a44\u0005\u0532\u029a\u0002\u1a44\u1a45\u0007", + "\u0113\u0002\u0002\u1a45\u1a46\u0007`\u0002\u0002\u1a46\u1a47\u0005", + "\u054e\u02a8\u0002\u1a47\u1ae4\u0003\u0002\u0002\u0002\u1a48\u1a49\u0007", + "\u008c\u0002\u0002\u1a49\u1a4a\u0007\u00bf\u0002\u0002\u1a4a\u1a4b\u0005", + "\u020e\u0108\u0002\u1a4b\u1a4c\u0007\u0113\u0002\u0002\u1a4c\u1a4d\u0007", + "`\u0002\u0002\u1a4d\u1a4e\u0005\u054e\u02a8\u0002\u1a4e\u1ae4\u0003", + "\u0002\u0002\u0002\u1a4f\u1a50\u0007\u008c\u0002\u0002\u1a50\u1a51\u0007", + "\u00d5\u0002\u0002\u1a51\u1a52\u0005\u0274\u013b\u0002\u1a52\u1a53\u0007", + "\u0113\u0002\u0002\u1a53\u1a54\u0007`\u0002\u0002\u1a54\u1a55\u0005", + "\u054e\u02a8\u0002\u1a55\u1ae4\u0003\u0002\u0002\u0002\u1a56\u1a57\u0007", + "\u008c\u0002\u0002\u1a57\u1a58\u0005\u0136\u009c\u0002\u1a58\u1a59\u0007", + "\u00f0\u0002\u0002\u1a59\u1a5a\u0005\u0532\u029a\u0002\u1a5a\u1a5b\u0007", + "\u0113\u0002\u0002\u1a5b\u1a5c\u0007`\u0002\u0002\u1a5c\u1a5d\u0005", + "\u054e\u02a8\u0002\u1a5d\u1ae4\u0003\u0002\u0002\u0002\u1a5e\u1a5f\u0007", + "\u008c\u0002\u0002\u1a5f\u1a60\u0007\u00f1\u0002\u0002\u1a60\u1a61\u0007", + "\u010b\u0002\u0002\u1a61\u1a62\u0005\u0126\u0094\u0002\u1a62\u1a63\u0007", + "\u0113\u0002\u0002\u1a63\u1a64\u0007`\u0002\u0002\u1a64\u1a65\u0005", + "\u054e\u02a8\u0002\u1a65\u1ae4\u0003\u0002\u0002\u0002\u1a66\u1a67\u0007", + "\u008c\u0002\u0002\u1a67\u1a68\u0007\u010f\u0002\u0002\u1a68\u1a69\u0005", + "\u02b2\u015a\u0002\u1a69\u1a6a\u0007\u0113\u0002\u0002\u1a6a\u1a6b\u0007", + "`\u0002\u0002\u1a6b\u1a6c\u0005\u054e\u02a8\u0002\u1a6c\u1ae4\u0003", + "\u0002\u0002\u0002\u1a6d\u1a6e\u0007\u008c\u0002\u0002\u1a6e\u1a6f\u0007", + "\u010f\u0002\u0002\u1a6f\u1a70\u0007\u009e\u0002\u0002\u1a70\u1a71\u0005", + "\u020e\u0108\u0002\u1a71\u1a72\u0007f\u0002\u0002\u1a72\u1a73\u0005", + "\u0532\u029a\u0002\u1a73\u1a74\u0007\u0113\u0002\u0002\u1a74\u1a75\u0007", + "`\u0002\u0002\u1a75\u1a76\u0005\u054e\u02a8\u0002\u1a76\u1ae4\u0003", + "\u0002\u0002\u0002\u1a77\u1a78\u0007\u008c\u0002\u0002\u1a78\u1a79\u0007", + "\u010f\u0002\u0002\u1a79\u1a7a\u0007\u00d0\u0002\u0002\u1a7a\u1a7b\u0005", + "\u020e\u0108\u0002\u1a7b\u1a7c\u0007f\u0002\u0002\u1a7c\u1a7d\u0005", + "\u0532\u029a\u0002\u1a7d\u1a7e\u0007\u0113\u0002\u0002\u1a7e\u1a7f\u0007", + "`\u0002\u0002\u1a7f\u1a80\u0005\u054e\u02a8\u0002\u1a80\u1ae4\u0003", + "\u0002\u0002\u0002\u1a81\u1a82\u0007\u008c\u0002\u0002\u1a82\u1a83\u0007", + "\u0121\u0002\u0002\u1a83\u1a84\u0005\u0274\u013b\u0002\u1a84\u1a85\u0007", + "\u0113\u0002\u0002\u1a85\u1a86\u0007`\u0002\u0002\u1a86\u1a87\u0005", + "\u054e\u02a8\u0002\u1a87\u1ae4\u0003\u0002\u0002\u0002\u1a88\u1a89\u0007", + "\u008c\u0002\u0002\u1a89\u1a8a\u0007\u01b3\u0002\u0002\u1a8a\u1a8b\u0005", + "\u0274\u013b\u0002\u1a8b\u1a8c\u0007\u0113\u0002\u0002\u1a8c\u1a8d\u0007", + "`\u0002\u0002\u1a8d\u1a8e\u0005\u054e\u02a8\u0002\u1a8e\u1ae4\u0003", + "\u0002\u0002\u0002\u1a8f\u1a90\u0007\u008c\u0002\u0002\u1a90\u1a91\u0007", + "\u013c\u0002\u0002\u1a91\u1a92\u0005\u0532\u029a\u0002\u1a92\u1a93\u0007", + "\u0113\u0002\u0002\u1a93\u1a94\u0007`\u0002\u0002\u1a94\u1a95\u0005", + "\u054e\u02a8\u0002\u1a95\u1ae4\u0003\u0002\u0002\u0002\u1a96\u1a97\u0007", + "\u008c\u0002\u0002\u1a97\u1a98\u0007\u0161\u0002\u0002\u1a98\u1a99\u0005", + "\u020e\u0108\u0002\u1a99\u1a9a\u0007\u0113\u0002\u0002\u1a9a\u1a9b\u0007", + "`\u0002\u0002\u1a9b\u1a9c\u0005\u054e\u02a8\u0002\u1a9c\u1ae4\u0003", + "\u0002\u0002\u0002\u1a9d\u1a9e\u0007\u008c\u0002\u0002\u1a9e\u1a9f\u0007", + "\u0158\u0002\u0002\u1a9f\u1aa0\u0005\u0532\u029a\u0002\u1aa0\u1aa1\u0007", + "\u0113\u0002\u0002\u1aa1\u1aa2\u0007`\u0002\u0002\u1aa2\u1aa3\u0005", + "\u054e\u02a8\u0002\u1aa3\u1ae4\u0003\u0002\u0002\u0002\u1aa4\u1aa5\u0007", + "\u008c\u0002\u0002\u1aa5\u1aa6\u0007\u014f\u0002\u0002\u1aa6\u1aa7\u0005", + "\u020e\u0108\u0002\u1aa7\u1aa8\u0007\u0113\u0002\u0002\u1aa8\u1aa9\u0007", + "`\u0002\u0002\u1aa9\u1aaa\u0005\u054e\u02a8\u0002\u1aaa\u1ae4\u0003", + "\u0002\u0002\u0002\u1aab\u1aac\u0007\u008c\u0002\u0002\u1aac\u1aad\u0007", + "\u015c\u0002\u0002\u1aad\u1aae\u0007\u013e\u0002\u0002\u1aae\u1aaf\u0007", + "\u00bb\u0002\u0002\u1aaf\u1ab0\u0005\u020e\u0108\u0002\u1ab0\u1ab1\u0007", + "\u0113\u0002\u0002\u1ab1\u1ab2\u0007`\u0002\u0002\u1ab2\u1ab3\u0005", + "\u054e\u02a8\u0002\u1ab3\u1ae4\u0003\u0002\u0002\u0002\u1ab4\u1ab5\u0007", + "\u008c\u0002\u0002\u1ab5\u1ab6\u0007\u015c\u0002\u0002\u1ab6\u1ab7\u0007", + "\u013e\u0002\u0002\u1ab7\u1ab8\u0007\u00a5\u0002\u0002\u1ab8\u1ab9\u0005", + "\u020e\u0108\u0002\u1ab9\u1aba\u0007\u0113\u0002\u0002\u1aba\u1abb\u0007", + "`\u0002\u0002\u1abb\u1abc\u0005\u054e\u02a8\u0002\u1abc\u1ae4\u0003", + "\u0002\u0002\u0002\u1abd\u1abe\u0007\u008c\u0002\u0002\u1abe\u1abf\u0007", + "A\u0002\u0002\u1abf\u1ac0\u0007\u00b0\u0002\u0002\u1ac0\u1ac1\u0007", + "\u0176\u0002\u0002\u1ac1\u1ac2\u0005\u0532\u029a\u0002\u1ac2\u1ac3\u0007", + "\u0113\u0002\u0002\u1ac3\u1ac4\u0007`\u0002\u0002\u1ac4\u1ac5\u0005", + "\u054e\u02a8\u0002\u1ac5\u1ae4\u0003\u0002\u0002\u0002\u1ac6\u1ac7\u0007", + "\u008c\u0002\u0002\u1ac7\u1ac8\u0007\u0144\u0002\u0002\u1ac8\u1ac9\u0005", + "\u0532\u029a\u0002\u1ac9\u1aca\u0007\u0113\u0002\u0002\u1aca\u1acb\u0007", + "`\u0002\u0002\u1acb\u1acc\u0005\u054e\u02a8\u0002\u1acc\u1ae4\u0003", + "\u0002\u0002\u0002\u1acd\u1ace\u0007\u008c\u0002\u0002\u1ace\u1acf\u0007", + "\u00c8\u0002\u0002\u1acf\u1ad0\u0007\u015e\u0002\u0002\u1ad0\u1ad1\u0005", + "\u0532\u029a\u0002\u1ad1\u1ad2\u0007\u0113\u0002\u0002\u1ad2\u1ad3\u0007", + "`\u0002\u0002\u1ad3\u1ad4\u0005\u054e\u02a8\u0002\u1ad4\u1ae4\u0003", + "\u0002\u0002\u0002\u1ad5\u1ad6\u0007\u008c\u0002\u0002\u1ad6\u1ad7\u0007", + "\u01bd\u0002\u0002\u1ad7\u1ad8\u0005\u0532\u029a\u0002\u1ad8\u1ad9\u0007", + "\u0113\u0002\u0002\u1ad9\u1ada\u0007`\u0002\u0002\u1ada\u1adb\u0005", + "\u054e\u02a8\u0002\u1adb\u1ae4\u0003\u0002\u0002\u0002\u1adc\u1add\u0007", + "\u008c\u0002\u0002\u1add\u1ade\u0007\u01bc\u0002\u0002\u1ade\u1adf\u0005", + "\u0532\u029a\u0002\u1adf\u1ae0\u0007\u0113\u0002\u0002\u1ae0\u1ae1\u0007", + "`\u0002\u0002\u1ae1\u1ae2\u0005\u054e\u02a8\u0002\u1ae2\u1ae4\u0003", + "\u0002\u0002\u0002\u1ae3\u1a2c\u0003\u0002\u0002\u0002\u1ae3\u1a33\u0003", + "\u0002\u0002\u0002\u1ae3\u1a3a\u0003\u0002\u0002\u0002\u1ae3\u1a41\u0003", + "\u0002\u0002\u0002\u1ae3\u1a48\u0003\u0002\u0002\u0002\u1ae3\u1a4f\u0003", + "\u0002\u0002\u0002\u1ae3\u1a56\u0003\u0002\u0002\u0002\u1ae3\u1a5e\u0003", + "\u0002\u0002\u0002\u1ae3\u1a66\u0003\u0002\u0002\u0002\u1ae3\u1a6d\u0003", + "\u0002\u0002\u0002\u1ae3\u1a77\u0003\u0002\u0002\u0002\u1ae3\u1a81\u0003", + "\u0002\u0002\u0002\u1ae3\u1a88\u0003\u0002\u0002\u0002\u1ae3\u1a8f\u0003", + "\u0002\u0002\u0002\u1ae3\u1a96\u0003\u0002\u0002\u0002\u1ae3\u1a9d\u0003", + "\u0002\u0002\u0002\u1ae3\u1aa4\u0003\u0002\u0002\u0002\u1ae3\u1aab\u0003", + "\u0002\u0002\u0002\u1ae3\u1ab4\u0003\u0002\u0002\u0002\u1ae3\u1abd\u0003", + "\u0002\u0002\u0002\u1ae3\u1ac6\u0003\u0002\u0002\u0002\u1ae3\u1acd\u0003", + "\u0002\u0002\u0002\u1ae3\u1ad5\u0003\u0002\u0002\u0002\u1ae3\u1adc\u0003", + "\u0002\u0002\u0002\u1ae4\u02eb\u0003\u0002\u0002\u0002\u1ae5\u1ae6\u0007", + "0\u0002\u0002\u1ae6\u1ae7\u0007\u01bd\u0002\u0002\u1ae7\u1ae8\u0005", + "\u0532\u029a\u0002\u1ae8\u1ae9\u0005\u02ee\u0178\u0002\u1ae9\u1aea\u0005", + "\u029a\u014e\u0002\u1aea\u02ed\u0003\u0002\u0002\u0002\u1aeb\u1aee\u0005", + "\u02f0\u0179\u0002\u1aec\u1aee\u0003\u0002\u0002\u0002\u1aed\u1aeb\u0003", + "\u0002\u0002\u0002\u1aed\u1aec\u0003\u0002\u0002\u0002\u1aee\u02ef\u0003", + "\u0002\u0002\u0002\u1aef\u1af0\u0007@\u0002\u0002\u1af0\u1af1\u0007", + "^\u0002\u0002\u1af1\u1af6\u0005\u042c\u0217\u0002\u1af2\u1af3\u0007", + "@\u0002\u0002\u1af3\u1af4\u0007 \u0002\u0002\u1af4\u1af6\u0007\u0157", + "\u0002\u0002\u1af5\u1aef\u0003\u0002\u0002\u0002\u1af5\u1af2\u0003\u0002", + "\u0002\u0002\u1af6\u02f1\u0003\u0002\u0002\u0002\u1af7\u1af8\u0007\u008c", + "\u0002\u0002\u1af8\u1af9\u0007\u01bd\u0002\u0002\u1af9\u1afa\u0005\u0532", + "\u029a\u0002\u1afa\u1afb\u0007\u0146\u0002\u0002\u1afb\u1afc\u0005\u01ce", + "\u00e8\u0002\u1afc\u1b13\u0003\u0002\u0002\u0002\u1afd\u1afe\u0007\u008c", + "\u0002\u0002\u1afe\u1aff\u0007\u01bd\u0002\u0002\u1aff\u1b00\u0005\u0532", + "\u029a\u0002\u1b00\u1b01\u0007\u0087\u0002\u0002\u1b01\u1b02\u0007^", + "\u0002\u0002\u1b02\u1b03\u0005\u042c\u0217\u0002\u1b03\u1b13\u0003\u0002", + "\u0002\u0002\u1b04\u1b05\u0007\u008c\u0002\u0002\u1b05\u1b06\u0007\u01bd", + "\u0002\u0002\u1b06\u1b07\u0005\u0532\u029a\u0002\u1b07\u1b08\u0007\u0146", + "\u0002\u0002\u1b08\u1b09\u0007^\u0002\u0002\u1b09\u1b0a\u0005\u042c", + "\u0217\u0002\u1b0a\u1b13\u0003\u0002\u0002\u0002\u1b0b\u1b0c\u0007\u008c", + "\u0002\u0002\u1b0c\u1b0d\u0007\u01bd\u0002\u0002\u1b0d\u1b0e\u0005\u0532", + "\u029a\u0002\u1b0e\u1b0f\u0007\u00c1\u0002\u0002\u1b0f\u1b10\u0007^", + "\u0002\u0002\u1b10\u1b11\u0005\u042c\u0217\u0002\u1b11\u1b13\u0003\u0002", + "\u0002\u0002\u1b12\u1af7\u0003\u0002\u0002\u0002\u1b12\u1afd\u0003\u0002", + "\u0002\u0002\u1b12\u1b04\u0003\u0002\u0002\u0002\u1b12\u1b0b\u0003\u0002", + "\u0002\u0002\u1b13\u02f3\u0003\u0002\u0002\u0002\u1b14\u1b15\u00070", + "\u0002\u0002\u1b15\u1b16\u0007\u01bc\u0002\u0002\u1b16\u1b17\u0005\u0532", + "\u029a\u0002\u1b17\u1b18\u0007\u00a6\u0002\u0002\u1b18\u1b19\u0005\u0544", + "\u02a3\u0002\u1b19\u1b1a\u0007\u01bd\u0002\u0002\u1b1a\u1b1b\u0005\u02f6", + "\u017c\u0002\u1b1b\u1b1c\u0005\u029a\u014e\u0002\u1b1c\u02f5\u0003\u0002", + "\u0002\u0002\u1b1d\u1b22\u0005\u02f8\u017d\u0002\u1b1e\u1b1f\u0007\b", + "\u0002\u0002\u1b1f\u1b21\u0005\u02f8\u017d\u0002\u1b20\u1b1e\u0003\u0002", + "\u0002\u0002\u1b21\u1b24\u0003\u0002\u0002\u0002\u1b22\u1b20\u0003\u0002", + "\u0002\u0002\u1b22\u1b23\u0003\u0002\u0002\u0002\u1b23\u02f7\u0003\u0002", + "\u0002\u0002\u1b24\u1b22\u0003\u0002\u0002\u0002\u1b25\u1b26\u0005\u0558", + "\u02ad\u0002\u1b26\u02f9\u0003\u0002\u0002\u0002\u1b27\u1b28\u0007\u008c", + "\u0002\u0002\u1b28\u1b29\u0007\u01bc\u0002\u0002\u1b29\u1b2a\u0005\u0532", + "\u029a\u0002\u1b2a\u1b2b\u0007\u0146\u0002\u0002\u1b2b\u1b2c\u0005\u01ce", + "\u00e8\u0002\u1b2c\u1b4d\u0003\u0002\u0002\u0002\u1b2d\u1b2e\u0007\u008c", + "\u0002\u0002\u1b2e\u1b2f\u0007\u01bc\u0002\u0002\u1b2f\u1b30\u0005\u0532", + "\u029a\u0002\u1b30\u1b31\u0007\u00a6\u0002\u0002\u1b31\u1b32\u0005\u0544", + "\u02a3\u0002\u1b32\u1b4d\u0003\u0002\u0002\u0002\u1b33\u1b34\u0007\u008c", + "\u0002\u0002\u1b34\u1b35\u0007\u01bc\u0002\u0002\u1b35\u1b36\u0005\u0532", + "\u029a\u0002\u1b36\u1b37\u0007\u012a\u0002\u0002\u1b37\u1b38\u0007\u01bd", + "\u0002\u0002\u1b38\u1b39\u0005\u029a\u014e\u0002\u1b39\u1b4d\u0003\u0002", + "\u0002\u0002\u1b3a\u1b3b\u0007\u008c\u0002\u0002\u1b3b\u1b3c\u0007\u01bc", + "\u0002\u0002\u1b3c\u1b3d\u0005\u0532\u029a\u0002\u1b3d\u1b3e\u0007\u0146", + "\u0002\u0002\u1b3e\u1b3f\u0007\u01bd\u0002\u0002\u1b3f\u1b40\u0005\u02f6", + "\u017c\u0002\u1b40\u1b41\u0005\u029a\u014e\u0002\u1b41\u1b4d\u0003\u0002", + "\u0002\u0002\u1b42\u1b43\u0007\u008c\u0002\u0002\u1b43\u1b44\u0007\u01bc", + "\u0002\u0002\u1b44\u1b45\u0005\u0532\u029a\u0002\u1b45\u1b46\u0007\u00c3", + "\u0002\u0002\u1b46\u1b4d\u0003\u0002\u0002\u0002\u1b47\u1b48\u0007\u008c", + "\u0002\u0002\u1b48\u1b49\u0007\u01bc\u0002\u0002\u1b49\u1b4a\u0005\u0532", + "\u029a\u0002\u1b4a\u1b4b\u0007\u00bc\u0002\u0002\u1b4b\u1b4d\u0003\u0002", + "\u0002\u0002\u1b4c\u1b27\u0003\u0002\u0002\u0002\u1b4c\u1b2d\u0003\u0002", + "\u0002\u0002\u1b4c\u1b33\u0003\u0002\u0002\u0002\u1b4c\u1b3a\u0003\u0002", + "\u0002\u0002\u1b4c\u1b42\u0003\u0002\u0002\u0002\u1b4c\u1b47\u0003\u0002", + "\u0002\u0002\u1b4d\u02fb\u0003\u0002\u0002\u0002\u1b4e\u1b4f\u0007\u00c1", + "\u0002\u0002\u1b4f\u1b50\u0007\u01bc\u0002\u0002\u1b50\u1b51\u0005\u0532", + "\u029a\u0002\u1b51\u1b52\u0005n8\u0002\u1b52\u1b5b\u0003\u0002\u0002", + "\u0002\u1b53\u1b54\u0007\u00c1\u0002\u0002\u1b54\u1b55\u0007\u01bc\u0002", + "\u0002\u1b55\u1b56\u0007\u00de\u0002\u0002\u1b56\u1b57\u0007\u0185\u0002", + "\u0002\u1b57\u1b58\u0005\u0532\u029a\u0002\u1b58\u1b59\u0005n8\u0002", + "\u1b59\u1b5b\u0003\u0002\u0002\u0002\u1b5a\u1b4e\u0003\u0002\u0002\u0002", + "\u1b5a\u1b53\u0003\u0002\u0002\u0002\u1b5b\u02fd\u0003\u0002\u0002\u0002", + "\u1b5c\u1b5d\u00070\u0002\u0002\u1b5d\u1b5e\u0005\u026c\u0137\u0002", + "\u1b5e\u1b5f\u0007\u013a\u0002\u0002\u1b5f\u1b60\u0005\u0532\u029a\u0002", + "\u1b60\u1b61\u0007&\u0002\u0002\u1b61\u1b62\u0007R\u0002\u0002\u1b62", + "\u1b63\u0005\u0308\u0185\u0002\u1b63\u1b64\u0007`\u0002\u0002\u1b64", + "\u1b65\u0005\u052e\u0298\u0002\u1b65\u1b66\u0005\u043e\u0220\u0002\u1b66", + "\u1b67\u0007;\u0002\u0002\u1b67\u1b68\u0005\u030a\u0186\u0002\u1b68", + "\u1b69\u0005\u0300\u0181\u0002\u1b69\u02ff\u0003\u0002\u0002\u0002\u1b6a", + "\u1b71\u0007\u0107\u0002\u0002\u1b6b\u1b71\u0005\u0304\u0183\u0002\u1b6c", + "\u1b6d\u0007\u0004\u0002\u0002\u1b6d\u1b6e\u0005\u0302\u0182\u0002\u1b6e", + "\u1b6f\u0007\u0005\u0002\u0002\u1b6f\u1b71\u0003\u0002\u0002\u0002\u1b70", + "\u1b6a\u0003\u0002\u0002\u0002\u1b70\u1b6b\u0003\u0002\u0002\u0002\u1b70", + "\u1b6c\u0003\u0002\u0002\u0002\u1b71\u0301\u0003\u0002\u0002\u0002\u1b72", + "\u1b77\u0005\u0306\u0184\u0002\u1b73\u1b74\u0007\t\u0002\u0002\u1b74", + "\u1b76\u0005\u0306\u0184\u0002\u1b75\u1b73\u0003\u0002\u0002\u0002\u1b76", + "\u1b79\u0003\u0002\u0002\u0002\u1b77\u1b75\u0003\u0002\u0002\u0002\u1b77", + "\u1b78\u0003\u0002\u0002\u0002\u1b78\u0303\u0003\u0002\u0002\u0002\u1b79", + "\u1b77\u0003\u0002\u0002\u0002\u1b7a\u1b80\u0005\u03ba\u01de\u0002\u1b7b", + "\u1b80\u0005\u0388\u01c5\u0002\u1b7c\u1b80\u0005\u03a8\u01d5\u0002\u1b7d", + "\u1b80\u0005\u039a\u01ce\u0002\u1b7e\u1b80\u0005\u030c\u0187\u0002\u1b7f", + "\u1b7a\u0003\u0002\u0002\u0002\u1b7f\u1b7b\u0003\u0002\u0002\u0002\u1b7f", + "\u1b7c\u0003\u0002\u0002\u0002\u1b7f\u1b7d\u0003\u0002\u0002\u0002\u1b7f", + "\u1b7e\u0003\u0002\u0002\u0002\u1b80\u0305\u0003\u0002\u0002\u0002\u1b81", + "\u1b84\u0005\u0304\u0183\u0002\u1b82\u1b84\u0003\u0002\u0002\u0002\u1b83", + "\u1b81\u0003\u0002\u0002\u0002\u1b83\u1b82\u0003\u0002\u0002\u0002\u1b84", + "\u0307\u0003\u0002\u0002\u0002\u1b85\u1b86\t\u001f\u0002\u0002\u1b86", + "\u0309\u0003\u0002\u0002\u0002\u1b87\u1b8b\u0007\u00eb\u0002\u0002\u1b88", + "\u1b8b\u0007\u008b\u0002\u0002\u1b89\u1b8b\u0003\u0002\u0002\u0002\u1b8a", + "\u1b87\u0003\u0002\u0002\u0002\u1b8a\u1b88\u0003\u0002\u0002\u0002\u1b8a", + "\u1b89\u0003\u0002\u0002\u0002\u1b8b\u030b\u0003\u0002\u0002\u0002\u1b8c", + "\u1b8d\u0007\u0108\u0002\u0002\u1b8d\u1b8e\u0005\u0552\u02aa\u0002\u1b8e", + "\u1b8f\u0005\u030e\u0188\u0002\u1b8f\u030d\u0003\u0002\u0002\u0002\u1b90", + "\u1b91\u0007\b\u0002\u0002\u1b91\u1b94\u0005\u0544\u02a3\u0002\u1b92", + "\u1b94\u0003\u0002\u0002\u0002\u1b93\u1b90\u0003\u0002\u0002\u0002\u1b93", + "\u1b92\u0003\u0002\u0002\u0002\u1b94\u030f\u0003\u0002\u0002\u0002\u1b95", + "\u1b96\u0007\u00f5\u0002\u0002\u1b96\u1b97\u0005\u0552\u02aa\u0002\u1b97", + "\u0311\u0003\u0002\u0002\u0002\u1b98\u1b99\u0007\u0167\u0002\u0002\u1b99", + "\u1b9d\u0005\u0552\u02aa\u0002\u1b9a\u1b9b\u0007\u0167\u0002\u0002\u1b9b", + "\u1b9d\u0007\u000b\u0002\u0002\u1b9c\u1b98\u0003\u0002\u0002\u0002\u1b9c", + "\u1b9a\u0003\u0002\u0002\u0002\u1b9d\u0313\u0003\u0002\u0002\u0002\u1b9e", + "\u1b9f\u0007\u0083\u0002\u0002\u1b9f\u1ba0\u0005\u0316\u018c\u0002\u1ba0", + "\u1ba1\u0005\u031e\u0190\u0002\u1ba1\u1bd1\u0003\u0002\u0002\u0002\u1ba2", + "\u1ba3\u0007\u0094\u0002\u0002\u1ba3\u1ba4\u0005\u0316\u018c\u0002\u1ba4", + "\u1ba5\u0005\u031c\u018f\u0002\u1ba5\u1bd1\u0003\u0002\u0002\u0002\u1ba6", + "\u1ba7\u0007\u014d\u0002\u0002\u1ba7\u1ba8\u0007\u015d\u0002\u0002\u1ba8", + "\u1bd1\u0005\u031c\u018f\u0002\u1ba9\u1baa\u0007\u00a3\u0002\u0002\u1baa", + "\u1bab\u0005\u0316\u018c\u0002\u1bab\u1bac\u0005\u031e\u0190\u0002\u1bac", + "\u1bd1\u0003\u0002\u0002\u0002\u1bad\u1bae\u0007\u01bf\u0002\u0002\u1bae", + "\u1baf\u0005\u0316\u018c\u0002\u1baf\u1bb0\u0005\u031e\u0190\u0002\u1bb0", + "\u1bd1\u0003\u0002\u0002\u0002\u1bb1\u1bb2\u0007\u0138\u0002\u0002\u1bb2", + "\u1bb3\u0005\u0316\u018c\u0002\u1bb3\u1bb4\u0005\u031e\u0190\u0002\u1bb4", + "\u1bd1\u0003\u0002\u0002\u0002\u1bb5\u1bb6\u0007\u013b\u0002\u0002\u1bb6", + "\u1bd1\u0005\u0552\u02aa\u0002\u1bb7\u1bb8\u0007\u012d\u0002\u0002\u1bb8", + "\u1bb9\u0007\u013b\u0002\u0002\u1bb9\u1bd1\u0005\u0552\u02aa\u0002\u1bba", + "\u1bbb\u0007\u012d\u0002\u0002\u1bbb\u1bd1\u0005\u0552\u02aa\u0002\u1bbc", + "\u1bbd\u0007\u0138\u0002\u0002\u1bbd\u1bbe\u0005\u0316\u018c\u0002\u1bbe", + "\u1bbf\u0007`\u0002\u0002\u1bbf\u1bc0\u0007\u013b\u0002\u0002\u1bc0", + "\u1bc1\u0005\u0552\u02aa\u0002\u1bc1\u1bd1\u0003\u0002\u0002\u0002\u1bc2", + "\u1bc3\u0007\u0138\u0002\u0002\u1bc3\u1bc4\u0005\u0316\u018c\u0002\u1bc4", + "\u1bc5\u0007`\u0002\u0002\u1bc5\u1bc6\u0005\u0552\u02aa\u0002\u1bc6", + "\u1bd1\u0003\u0002\u0002\u0002\u1bc7\u1bc8\u0007\u011b\u0002\u0002\u1bc8", + "\u1bc9\u0007\u015d\u0002\u0002\u1bc9\u1bd1\u0005\u0544\u02a3\u0002\u1bca", + "\u1bcb\u0007\u00a3\u0002\u0002\u1bcb\u1bcc\u0007\u011c\u0002\u0002\u1bcc", + "\u1bd1\u0005\u0544\u02a3\u0002\u1bcd\u1bce\u0007\u0138\u0002\u0002\u1bce", + "\u1bcf\u0007\u011c\u0002\u0002\u1bcf\u1bd1\u0005\u0544\u02a3\u0002\u1bd0", + "\u1b9e\u0003\u0002\u0002\u0002\u1bd0\u1ba2\u0003\u0002\u0002\u0002\u1bd0", + "\u1ba6\u0003\u0002\u0002\u0002\u1bd0\u1ba9\u0003\u0002\u0002\u0002\u1bd0", + "\u1bad\u0003\u0002\u0002\u0002\u1bd0\u1bb1\u0003\u0002\u0002\u0002\u1bd0", + "\u1bb5\u0003\u0002\u0002\u0002\u1bd0\u1bb7\u0003\u0002\u0002\u0002\u1bd0", + "\u1bba\u0003\u0002\u0002\u0002\u1bd0\u1bbc\u0003\u0002\u0002\u0002\u1bd0", + "\u1bc2\u0003\u0002\u0002\u0002\u1bd0\u1bc7\u0003\u0002\u0002\u0002\u1bd0", + "\u1bca\u0003\u0002\u0002\u0002\u1bd0\u1bcd\u0003\u0002\u0002\u0002\u1bd1", + "\u0315\u0003\u0002\u0002\u0002\u1bd2\u1bd6\u0007\u0175\u0002\u0002\u1bd3", + "\u1bd6\u0007\u015d\u0002\u0002\u1bd4\u1bd6\u0003\u0002\u0002\u0002\u1bd5", + "\u1bd2\u0003\u0002\u0002\u0002\u1bd5\u1bd3\u0003\u0002\u0002\u0002\u1bd5", + "\u1bd4\u0003\u0002\u0002\u0002\u1bd6\u0317\u0003\u0002\u0002\u0002\u1bd7", + "\u1bd8\u0007\u00ed\u0002\u0002\u1bd8\u1bd9\u0007\u00f4\u0002\u0002\u1bd9", + "\u1be2\u0005B\"\u0002\u1bda\u1bdb\u0007\u0125\u0002\u0002\u1bdb\u1be2", + "\u0007S\u0002\u0002\u1bdc\u1bdd\u0007\u0125\u0002\u0002\u1bdd\u1be2", + "\u0007\u0177\u0002\u0002\u1bde\u1be2\u00078\u0002\u0002\u1bdf\u1be0", + "\u0007O\u0002\u0002\u1be0\u1be2\u00078\u0002\u0002\u1be1\u1bd7\u0003", + "\u0002\u0002\u0002\u1be1\u1bda\u0003\u0002\u0002\u0002\u1be1\u1bdc\u0003", + "\u0002\u0002\u0002\u1be1\u1bde\u0003\u0002\u0002\u0002\u1be1\u1bdf\u0003", + "\u0002\u0002\u0002\u1be2\u0319\u0003\u0002\u0002\u0002\u1be3\u1bea\u0005", + "\u0318\u018d\u0002\u1be4\u1be6\u0007\b\u0002\u0002\u1be5\u1be4\u0003", + "\u0002\u0002\u0002\u1be5\u1be6\u0003\u0002\u0002\u0002\u1be6\u1be7\u0003", + "\u0002\u0002\u0002\u1be7\u1be9\u0005\u0318\u018d\u0002\u1be8\u1be5\u0003", + "\u0002\u0002\u0002\u1be9\u1bec\u0003\u0002\u0002\u0002\u1bea\u1be8\u0003", + "\u0002\u0002\u0002\u1bea\u1beb\u0003\u0002\u0002\u0002\u1beb\u031b\u0003", + "\u0002\u0002\u0002\u1bec\u1bea\u0003\u0002\u0002\u0002\u1bed\u1bf0\u0005", + "\u031a\u018e\u0002\u1bee\u1bf0\u0003\u0002\u0002\u0002\u1bef\u1bed\u0003", + "\u0002\u0002\u0002\u1bef\u1bee\u0003\u0002\u0002\u0002\u1bf0\u031d\u0003", + "\u0002\u0002\u0002\u1bf1\u1bf3\u0007#\u0002\u0002\u1bf2\u1bf4\u0007", + "\u0106\u0002\u0002\u1bf3\u1bf2\u0003\u0002\u0002\u0002\u1bf3\u1bf4\u0003", + "\u0002\u0002\u0002\u1bf4\u1bf5\u0003\u0002\u0002\u0002\u1bf5\u1bf8\u0007", + "\u009b\u0002\u0002\u1bf6\u1bf8\u0003\u0002\u0002\u0002\u1bf7\u1bf1\u0003", + "\u0002\u0002\u0002\u1bf7\u1bf6\u0003\u0002\u0002\u0002\u1bf8\u031f\u0003", + "\u0002\u0002\u0002\u1bf9\u1bfc\u00070\u0002\u0002\u1bfa\u1bfb\u0007", + "T\u0002\u0002\u1bfb\u1bfd\u0007\u0130\u0002\u0002\u1bfc\u1bfa\u0003", + "\u0002\u0002\u0002\u1bfc\u1bfd\u0003\u0002\u0002\u0002\u1bfd\u1bfe\u0003", + "\u0002\u0002\u0002\u1bfe\u1c0c\u0005\u00b0Y\u0002\u1bff\u1c00\u0007", + "\u0171\u0002\u0002\u1c00\u1c01\u0005\u052e\u0298\u0002\u1c01\u1c02\u0005", + "\u00d8m\u0002\u1c02\u1c03\u0005x=\u0002\u1c03\u1c0d\u0003\u0002\u0002", + "\u0002\u1c04\u1c05\u0007\u0128\u0002\u0002\u1c05\u1c06\u0007\u0171\u0002", + "\u0002\u1c06\u1c07\u0005\u052e\u0298\u0002\u1c07\u1c08\u0007\u0004\u0002", + "\u0002\u1c08\u1c09\u0005\u00dan\u0002\u1c09\u1c0a\u0007\u0005\u0002", + "\u0002\u1c0a\u1c0b\u0005x=\u0002\u1c0b\u1c0d\u0003\u0002\u0002\u0002", + "\u1c0c\u1bff\u0003\u0002\u0002\u0002\u1c0c\u1c04\u0003\u0002\u0002\u0002", + "\u1c0d\u1c0e\u0003\u0002\u0002\u0002\u1c0e\u1c0f\u0007&\u0002\u0002", + "\u1c0f\u1c10\u0005\u03ba\u01de\u0002\u1c10\u1c11\u0005\u0322\u0192\u0002", + "\u1c11\u0321\u0003\u0002\u0002\u0002\u1c12\u1c14\u0007k\u0002\u0002", + "\u1c13\u1c15\t \u0002\u0002\u1c14\u1c13\u0003\u0002\u0002\u0002\u1c14", + "\u1c15\u0003\u0002\u0002\u0002\u1c15\u1c16\u0003\u0002\u0002\u0002\u1c16", + "\u1c17\u0007,\u0002\u0002\u1c17\u1c1a\u0007\u0110\u0002\u0002\u1c18", + "\u1c1a\u0003\u0002\u0002\u0002\u1c19\u1c12\u0003\u0002\u0002\u0002\u1c19", + "\u1c18\u0003\u0002\u0002\u0002\u1c1a\u0323\u0003\u0002\u0002\u0002\u1c1b", + "\u1c1c\u0007\u00f6\u0002\u0002\u1c1c\u1c1d\u0005\u0536\u029c\u0002\u1c1d", + "\u0325\u0003\u0002\u0002\u0002\u1c1e\u1c1f\u00070\u0002\u0002\u1c1f", + "\u1c20\u0007\u00b1\u0002\u0002\u1c20\u1c21\u0005\u0532\u029a\u0002\u1c21", + "\u1c22\u0005\u0012\n\u0002\u1c22\u1c23\u0005\u0328\u0195\u0002\u1c23", + "\u0327\u0003\u0002\u0002\u0002\u1c24\u1c27\u0005\u032a\u0196\u0002\u1c25", + "\u1c27\u0003\u0002\u0002\u0002\u1c26\u1c24\u0003\u0002\u0002\u0002\u1c26", + "\u1c25\u0003\u0002\u0002\u0002\u1c27\u0329\u0003\u0002\u0002\u0002\u1c28", + "\u1c2a\u0005\u032c\u0197\u0002\u1c29\u1c28\u0003\u0002\u0002\u0002\u1c2a", + "\u1c2b\u0003\u0002\u0002\u0002\u1c2b\u1c29\u0003\u0002\u0002\u0002\u1c2b", + "\u1c2c\u0003\u0002\u0002\u0002\u1c2c\u032b\u0003\u0002\u0002\u0002\u1c2d", + "\u1c2e\u0005\u032e\u0198\u0002\u1c2e\u1c32\u0005\u0330\u0199\u0002\u1c2f", + "\u1c33\u0005\u054a\u02a6\u0002\u1c30\u1c33\u0005D#\u0002\u1c31\u1c33", + "\u00077\u0002\u0002\u1c32\u1c2f\u0003\u0002\u0002\u0002\u1c32\u1c30", + "\u0003\u0002\u0002\u0002\u1c32\u1c31\u0003\u0002\u0002\u0002\u1c33\u032d", + "\u0003\u0002\u0002\u0002\u1c34\u1c3d\u0005\u055a\u02ae\u0002\u1c35\u1c36", + "\u0007\u00a6\u0002\u0002\u1c36\u1c3d\u0007L\u0002\u0002\u1c37\u1c3d", + "\u0007\u00c4\u0002\u0002\u1c38\u1c3d\u0007\u00f8\u0002\u0002\u1c39\u1c3d", + "\u0007\u0113\u0002\u0002\u1c3a\u1c3d\u0007\u0158\u0002\u0002\u1c3b\u1c3d", + "\u0007\u015a\u0002\u0002\u1c3c\u1c34\u0003\u0002\u0002\u0002\u1c3c\u1c35", + "\u0003\u0002\u0002\u0002\u1c3c\u1c37\u0003\u0002\u0002\u0002\u1c3c\u1c38", + "\u0003\u0002\u0002\u0002\u1c3c\u1c39\u0003\u0002\u0002\u0002\u1c3c\u1c3a", + "\u0003\u0002\u0002\u0002\u1c3c\u1c3b\u0003\u0002\u0002\u0002\u1c3d\u032f", + "\u0003\u0002\u0002\u0002\u1c3e\u1c41\u0007\f\u0002\u0002\u1c3f\u1c41", + "\u0003\u0002\u0002\u0002\u1c40\u1c3e\u0003\u0002\u0002\u0002\u1c40\u1c3f", + "\u0003\u0002\u0002\u0002\u1c41\u0331\u0003\u0002\u0002\u0002\u1c42\u1c43", + "\u0007\u008c\u0002\u0002\u1c43\u1c44\u0007\u00b1\u0002\u0002\u1c44\u1c4b", + "\u0005\u0532\u029a\u0002\u1c45\u1c46\u0007k\u0002\u0002\u1c46\u1c4c", + "\u0005\u0328\u0195\u0002\u1c47\u1c4c\u0005\u0328\u0195\u0002\u1c48\u1c49", + "\u0007\u0146\u0002\u0002\u1c49\u1c4a\u0007\u0158\u0002\u0002\u1c4a\u1c4c", + "\u0005\u0532\u029a\u0002\u1c4b\u1c45\u0003\u0002\u0002\u0002\u1c4b\u1c47", + "\u0003\u0002\u0002\u0002\u1c4b\u1c48\u0003\u0002\u0002\u0002\u1c4c\u0333", + "\u0003\u0002\u0002\u0002\u1c4d\u1c4e\u0007\u008c\u0002\u0002\u1c4e\u1c4f", + "\u0007\u00b1\u0002\u0002\u1c4f\u1c50\u0005\u0532\u029a\u0002\u1c50\u1c51", + "\u0005R*\u0002\u1c51\u0335\u0003\u0002\u0002\u0002\u1c52\u1c53\u0007", + "\u00c1\u0002\u0002\u1c53\u1c56\u0007\u00b1\u0002\u0002\u1c54\u1c55\u0007", + "\u00de\u0002\u0002\u1c55\u1c57\u0007\u0185\u0002\u0002\u1c56\u1c54\u0003", + "\u0002\u0002\u0002\u1c56\u1c57\u0003\u0002\u0002\u0002\u1c57\u1c58\u0003", + "\u0002\u0002\u0002\u1c58\u1c5e\u0005\u0532\u029a\u0002\u1c59\u1c5a\u0005", + "\u0012\n\u0002\u1c5a\u1c5b\u0007\u0004\u0002\u0002\u1c5b\u1c5c\u0005", + "\u0338\u019d\u0002\u1c5c\u1c5d\u0007\u0005\u0002\u0002\u1c5d\u1c5f\u0003", + "\u0002\u0002\u0002\u1c5e\u1c59\u0003\u0002\u0002\u0002\u1c5e\u1c5f\u0003", + "\u0002\u0002\u0002\u1c5f\u0337\u0003\u0002\u0002\u0002\u1c60\u1c65\u0005", + "\u033a\u019e\u0002\u1c61\u1c62\u0007\b\u0002\u0002\u1c62\u1c64\u0005", + "\u033a\u019e\u0002\u1c63\u1c61\u0003\u0002\u0002\u0002\u1c64\u1c67\u0003", + "\u0002\u0002\u0002\u1c65\u1c63\u0003\u0002\u0002\u0002\u1c65\u1c66\u0003", + "\u0002\u0002\u0002\u1c66\u0339\u0003\u0002\u0002\u0002\u1c67\u1c65\u0003", + "\u0002\u0002\u0002\u1c68\u1c69\u0007\u00d3\u0002\u0002\u1c69\u033b\u0003", + "\u0002\u0002\u0002\u1c6a\u1c6b\u0007\u008c\u0002\u0002\u1c6b\u1c6c\u0007", + "n\u0002\u0002\u1c6c\u1c6d\u0005\u020e\u0108\u0002\u1c6d\u1c6e\u0007", + "\u012a\u0002\u0002\u1c6e\u1c6f\u0007\u0170\u0002\u0002\u1c6f\u033d\u0003", + "\u0002\u0002\u0002\u1c70\u1c71\u0007\u008c\u0002\u0002\u1c71\u1c72\u0007", + "\u0156\u0002\u0002\u1c72\u1c73\t!\u0002\u0002\u1c73\u1c74\u00058\u001d", + "\u0002\u1c74\u033f\u0003\u0002\u0002\u0002\u1c75\u1c76\u00070\u0002", + "\u0002\u1c76\u1c77\u0007\u00bf\u0002\u0002\u1c77\u1c78\u0005\u020e\u0108", + "\u0002\u1c78\u1c79\u0005\u0344\u01a3\u0002\u1c79\u1c7a\u0005\u0456\u022c", + "\u0002\u1c7a\u1c7b\u0005\u00c2b\u0002\u1c7b\u0341\u0003\u0002\u0002", + "\u0002\u1c7c\u1c7d\u0007\u008c\u0002\u0002\u1c7d\u1c7e\u0007\u00bf\u0002", + "\u0002\u1c7e\u1c94\u0005\u020e\u0108\u0002\u1c7f\u1c95\u0005l7\u0002", + "\u1c80\u1c81\u0007\u00c1\u0002\u0002\u1c81\u1c82\u0007O\u0002\u0002", + "\u1c82\u1c95\u0007P\u0002\u0002\u1c83\u1c84\u0007\u0146\u0002\u0002", + "\u1c84\u1c85\u0007O\u0002\u0002\u1c85\u1c95\u0007P\u0002\u0002\u1c86", + "\u1c87\u0007\u0087\u0002\u0002\u1c87\u1c95\u0005\u00d2j\u0002\u1c88", + "\u1c89\u0007\u00c1\u0002\u0002\u1c89\u1c8c\u0007/\u0002\u0002\u1c8a", + "\u1c8b\u0007\u00de\u0002\u0002\u1c8b\u1c8d\u0007\u0185\u0002\u0002\u1c8c", + "\u1c8a\u0003\u0002\u0002\u0002\u1c8c\u1c8d\u0003\u0002\u0002\u0002\u1c8d", + "\u1c8e\u0003\u0002\u0002\u0002\u1c8e\u1c8f\u0005\u0532\u029a\u0002\u1c8f", + "\u1c90\u0005n8\u0002\u1c90\u1c95\u0003\u0002\u0002\u0002\u1c91\u1c92", + "\u0007\u016d\u0002\u0002\u1c92\u1c93\u0007/\u0002\u0002\u1c93\u1c95", + "\u0005\u0532\u029a\u0002\u1c94\u1c7f\u0003\u0002\u0002\u0002\u1c94\u1c80", + "\u0003\u0002\u0002\u0002\u1c94\u1c83\u0003\u0002\u0002\u0002\u1c94\u1c86", + "\u0003\u0002\u0002\u0002\u1c94\u1c88\u0003\u0002\u0002\u0002\u1c94\u1c91", + "\u0003\u0002\u0002\u0002\u1c95\u0343\u0003\u0002\u0002\u0002\u1c96\u1c99", + "\u0007&\u0002\u0002\u1c97\u1c99\u0003\u0002\u0002\u0002\u1c98\u1c96", + "\u0003\u0002\u0002\u0002\u1c98\u1c97\u0003\u0002\u0002\u0002\u1c99\u0345", + "\u0003\u0002\u0002\u0002\u1c9a\u1c9b\u0007\u008c\u0002\u0002\u1c9b\u1c9c", + "\u0007\u015c\u0002\u0002\u1c9c\u1c9d\u0007\u013e\u0002\u0002\u1c9d\u1c9e", + "\u0007\u00bb\u0002\u0002\u1c9e\u1c9f\u0005\u020e\u0108\u0002\u1c9f\u1ca0", + "\u0005\u01ce\u00e8\u0002\u1ca0\u0347\u0003\u0002\u0002\u0002\u1ca1\u1ca2", + "\u0007\u008c\u0002\u0002\u1ca2\u1ca3\u0007\u015c\u0002\u0002\u1ca3\u1ca4", + "\u0007\u013e\u0002\u0002\u1ca4\u1ca5\u0007\u00a5\u0002\u0002\u1ca5\u1ca6", + "\u0005\u020e\u0108\u0002\u1ca6\u1ca7\u0007\u0087\u0002\u0002\u1ca7\u1ca8", + "\u0007\u00fa\u0002\u0002\u1ca8\u1ca9\u0007@\u0002\u0002\u1ca9\u1caa", + "\u0005\u0530\u0299\u0002\u1caa\u1cab\u0005\u034a\u01a6\u0002\u1cab\u1cac", + "\u0005\u020c\u0107\u0002\u1cac\u1cea\u0003\u0002\u0002\u0002\u1cad\u1cae", + "\u0007\u008c\u0002\u0002\u1cae\u1caf\u0007\u015c\u0002\u0002\u1caf\u1cb0", + "\u0007\u013e\u0002\u0002\u1cb0\u1cb1\u0007\u00a5\u0002\u0002\u1cb1\u1cb2", + "\u0005\u020e\u0108\u0002\u1cb2\u1cb3\u0007\u008c\u0002\u0002\u1cb3\u1cb4", + "\u0007\u00fa\u0002\u0002\u1cb4\u1cb5\u0007@\u0002\u0002\u1cb5\u1cb6", + "\u0005\u0530\u0299\u0002\u1cb6\u1cb7\u0005\u034a\u01a6\u0002\u1cb7\u1cb8", + "\u0005\u020c\u0107\u0002\u1cb8\u1cea\u0003\u0002\u0002\u0002\u1cb9\u1cba", + "\u0007\u008c\u0002\u0002\u1cba\u1cbb\u0007\u015c\u0002\u0002\u1cbb\u1cbc", + "\u0007\u013e\u0002\u0002\u1cbc\u1cbd\u0007\u00a5\u0002\u0002\u1cbd\u1cbe", + "\u0005\u020e\u0108\u0002\u1cbe\u1cbf\u0007\u008c\u0002\u0002\u1cbf\u1cc0", + "\u0007\u00fa\u0002\u0002\u1cc0\u1cc1\u0007\u0130\u0002\u0002\u1cc1\u1cc2", + "\u0005\u020e\u0108\u0002\u1cc2\u1cc3\u0005\u034a\u01a6\u0002\u1cc3\u1cc4", + "\u0005\u020e\u0108\u0002\u1cc4\u1cea\u0003\u0002\u0002\u0002\u1cc5\u1cc6", + "\u0007\u008c\u0002\u0002\u1cc6\u1cc7\u0007\u015c\u0002\u0002\u1cc7\u1cc8", + "\u0007\u013e\u0002\u0002\u1cc8\u1cc9\u0007\u00a5\u0002\u0002\u1cc9\u1cca", + "\u0005\u020e\u0108\u0002\u1cca\u1ccb\u0007\u008c\u0002\u0002\u1ccb\u1ccc", + "\u0007\u00fa\u0002\u0002\u1ccc\u1ccd\u0007@\u0002\u0002\u1ccd\u1cce", + "\u0005\u0530\u0299\u0002\u1cce\u1ccf\u0007\u0130\u0002\u0002\u1ccf\u1cd0", + "\u0005\u020e\u0108\u0002\u1cd0\u1cd1\u0005\u034a\u01a6\u0002\u1cd1\u1cd2", + "\u0005\u020e\u0108\u0002\u1cd2\u1cea\u0003\u0002\u0002\u0002\u1cd3\u1cd4", + "\u0007\u008c\u0002\u0002\u1cd4\u1cd5\u0007\u015c\u0002\u0002\u1cd5\u1cd6", + "\u0007\u013e\u0002\u0002\u1cd6\u1cd7\u0007\u00a5\u0002\u0002\u1cd7\u1cd8", + "\u0005\u020e\u0108\u0002\u1cd8\u1cd9\u0007\u00c1\u0002\u0002\u1cd9\u1cda", + "\u0007\u00fa\u0002\u0002\u1cda\u1cdb\u0007@\u0002\u0002\u1cdb\u1cdc", + "\u0005\u0530\u0299\u0002\u1cdc\u1cea\u0003\u0002\u0002\u0002\u1cdd\u1cde", + "\u0007\u008c\u0002\u0002\u1cde\u1cdf\u0007\u015c\u0002\u0002\u1cdf\u1ce0", + "\u0007\u013e\u0002\u0002\u1ce0\u1ce1\u0007\u00a5\u0002\u0002\u1ce1\u1ce2", + "\u0005\u020e\u0108\u0002\u1ce2\u1ce3\u0007\u00c1\u0002\u0002\u1ce3\u1ce4", + "\u0007\u00fa\u0002\u0002\u1ce4\u1ce5\u0007\u00de\u0002\u0002\u1ce5\u1ce6", + "\u0007\u0185\u0002\u0002\u1ce6\u1ce7\u0007@\u0002\u0002\u1ce7\u1ce8", + "\u0005\u0530\u0299\u0002\u1ce8\u1cea\u0003\u0002\u0002\u0002\u1ce9\u1ca1", + "\u0003\u0002\u0002\u0002\u1ce9\u1cad\u0003\u0002\u0002\u0002\u1ce9\u1cb9", + "\u0003\u0002\u0002\u0002\u1ce9\u1cc5\u0003\u0002\u0002\u0002\u1ce9\u1cd3", + "\u0003\u0002\u0002\u0002\u1ce9\u1cdd\u0003\u0002\u0002\u0002\u1cea\u0349", + "\u0003\u0002\u0002\u0002\u1ceb\u1cec\u0007k\u0002\u0002\u1cec\u034b", + "\u0003\u0002\u0002\u0002\u1ced\u1cee\u00070\u0002\u0002\u1cee\u1cef", + "\u0005\u01ea\u00f6\u0002\u1cef\u1cf0\u0007\u00aa\u0002\u0002\u1cf0\u1cf1", + "\u0005\u020e\u0108\u0002\u1cf1\u1cf2\u0007@\u0002\u0002\u1cf2\u1cf3", + "\u0005\u0544\u02a3\u0002\u1cf3\u1cf4\u0007`\u0002\u0002\u1cf4\u1cf5", + "\u0005\u0544\u02a3\u0002\u1cf5\u1cf6\u0007B\u0002\u0002\u1cf6\u1cf7", + "\u0005\u020e\u0108\u0002\u1cf7\u034d\u0003\u0002\u0002\u0002\u1cf8\u1cf9", + "\u0007\u00a0\u0002\u0002\u1cf9\u1cfa\u0005\u0362\u01b2\u0002\u1cfa\u1cfb", + "\u0005\u052e\u0298\u0002\u1cfb\u1cfc\u0005\u0350\u01a9\u0002\u1cfc\u1d06", + "\u0003\u0002\u0002\u0002\u1cfd\u1cfe\u0007\u00a0\u0002\u0002\u1cfe\u1d06", + "\u0005\u0362\u01b2\u0002\u1cff\u1d00\u0007\u00a0\u0002\u0002\u1d00\u1d01", + "\u0005\u0362\u01b2\u0002\u1d01\u1d02\u0005\u0532\u029a\u0002\u1d02\u1d03", + "\u0007R\u0002\u0002\u1d03\u1d04\u0005\u052e\u0298\u0002\u1d04\u1d06", + "\u0003\u0002\u0002\u0002\u1d05\u1cf8\u0003\u0002\u0002\u0002\u1d05\u1cfd", + "\u0003\u0002\u0002\u0002\u1d05\u1cff\u0003\u0002\u0002\u0002\u1d06\u034f", + "\u0003\u0002\u0002\u0002\u1d07\u1d08\u0007f\u0002\u0002\u1d08\u1d0b", + "\u0005\u0532\u029a\u0002\u1d09\u1d0b\u0003\u0002\u0002\u0002\u1d0a\u1d07", + "\u0003\u0002\u0002\u0002\u1d0a\u1d09\u0003\u0002\u0002\u0002\u1d0b\u0351", + "\u0003\u0002\u0002\u0002\u1d0c\u1d0d\u0007\u016b\u0002\u0002\u1d0d\u1d0e", + "\u0005\u0364\u01b3\u0002\u1d0e\u1d0f\u0005\u0366\u01b4\u0002\u1d0f\u1d10", + "\u0005\u0362\u01b2\u0002\u1d10\u1d11\u0005\u0360\u01b1\u0002\u1d11\u1d12", + "\u0005\u036e\u01b8\u0002\u1d12\u1d1a\u0003\u0002\u0002\u0002\u1d13\u1d14", + "\u0007\u016b\u0002\u0002\u1d14\u1d15\u0007\u0004\u0002\u0002\u1d15\u1d16", + "\u0005\u0356\u01ac\u0002\u1d16\u1d17\u0007\u0005\u0002\u0002\u1d17\u1d18", + "\u0005\u036e\u01b8\u0002\u1d18\u1d1a\u0003\u0002\u0002\u0002\u1d19\u1d0c", + "\u0003\u0002\u0002\u0002\u1d19\u1d13\u0003\u0002\u0002\u0002\u1d1a\u0353", + "\u0003\u0002\u0002\u0002\u1d1b\u1d1c\u0005\u0358\u01ad\u0002\u1d1c\u1d1d", + "\u0005\u0362\u01b2\u0002\u1d1d\u1d1e\u0005\u036e\u01b8\u0002\u1d1e\u1d26", + "\u0003\u0002\u0002\u0002\u1d1f\u1d20\u0005\u0358\u01ad\u0002\u1d20\u1d21", + "\u0007\u0004\u0002\u0002\u1d21\u1d22\u0005\u0356\u01ac\u0002\u1d22\u1d23", + "\u0007\u0005\u0002\u0002\u1d23\u1d24\u0005\u036e\u01b8\u0002\u1d24\u1d26", + "\u0003\u0002\u0002\u0002\u1d25\u1d1b\u0003\u0002\u0002\u0002\u1d25\u1d1f", + "\u0003\u0002\u0002\u0002\u1d26\u0355\u0003\u0002\u0002\u0002\u1d27\u1d2c", + "\u0005\u035a\u01ae\u0002\u1d28\u1d29\u0007\b\u0002\u0002\u1d29\u1d2b", + "\u0005\u035a\u01ae\u0002\u1d2a\u1d28\u0003\u0002\u0002\u0002\u1d2b\u1d2e", + "\u0003\u0002\u0002\u0002\u1d2c\u1d2a\u0003\u0002\u0002\u0002\u1d2c\u1d2d", + "\u0003\u0002\u0002\u0002\u1d2d\u0357\u0003\u0002\u0002\u0002\u1d2e\u1d2c", + "\u0003\u0002\u0002\u0002\u1d2f\u1d30\t\"\u0002\u0002\u1d30\u0359\u0003", + "\u0002\u0002\u0002\u1d31\u1d32\u0005\u035c\u01af\u0002\u1d32\u1d33\u0005", + "\u035e\u01b0\u0002\u1d33\u035b\u0003\u0002\u0002\u0002\u1d34\u1d37\u0005", + "\u0556\u02ac\u0002\u1d35\u1d37\u0005\u0358\u01ad\u0002\u1d36\u1d34\u0003", + "\u0002\u0002\u0002\u1d36\u1d35\u0003\u0002\u0002\u0002\u1d37\u035d\u0003", + "\u0002\u0002\u0002\u1d38\u1d3c\u0005D#\u0002\u1d39\u1d3c\u0005\u0126", + "\u0094\u0002\u1d3a\u1d3c\u0003\u0002\u0002\u0002\u1d3b\u1d38\u0003\u0002", + "\u0002\u0002\u1d3b\u1d39\u0003\u0002\u0002\u0002\u1d3b\u1d3a\u0003\u0002", + "\u0002\u0002\u1d3c\u035f\u0003\u0002\u0002\u0002\u1d3d\u1d40\u0005\u0358", + "\u01ad\u0002\u1d3e\u1d40\u0003\u0002\u0002\u0002\u1d3f\u1d3d\u0003\u0002", + "\u0002\u0002\u1d3f\u1d3e\u0003\u0002\u0002\u0002\u1d40\u0361\u0003\u0002", + "\u0002\u0002\u1d41\u1d44\u0007\u0082\u0002\u0002\u1d42\u1d44\u0003\u0002", + "\u0002\u0002\u1d43\u1d41\u0003\u0002\u0002\u0002\u1d43\u1d42\u0003\u0002", + "\u0002\u0002\u1d44\u0363\u0003\u0002\u0002\u0002\u1d45\u1d48\u0007s", + "\u0002\u0002\u1d46\u1d48\u0003\u0002\u0002\u0002\u1d47\u1d45\u0003\u0002", + "\u0002\u0002\u1d47\u1d46\u0003\u0002\u0002\u0002\u1d48\u0365\u0003\u0002", + "\u0002\u0002\u1d49\u1d4c\u0007r\u0002\u0002\u1d4a\u1d4c\u0003\u0002", + "\u0002\u0002\u1d4b\u1d49\u0003\u0002\u0002\u0002\u1d4b\u1d4a\u0003\u0002", + "\u0002\u0002\u1d4c\u0367\u0003\u0002\u0002\u0002\u1d4d\u1d4e\u0007\u0004", + "\u0002\u0002\u1d4e\u1d4f\u0005\u0530\u0299\u0002\u1d4f\u1d50\u0007\u0005", + "\u0002\u0002\u1d50\u1d53\u0003\u0002\u0002\u0002\u1d51\u1d53\u0003\u0002", + "\u0002\u0002\u1d52\u1d4d\u0003\u0002\u0002\u0002\u1d52\u1d51\u0003\u0002", + "\u0002\u0002\u1d53\u0369\u0003\u0002\u0002\u0002\u1d54\u1d55\u0005\u052e", + "\u0298\u0002\u1d55\u1d56\u0005\u0368\u01b5\u0002\u1d56\u036b\u0003\u0002", + "\u0002\u0002\u1d57\u1d5c\u0005\u036a\u01b6\u0002\u1d58\u1d59\u0007\b", + "\u0002\u0002\u1d59\u1d5b\u0005\u036a\u01b6\u0002\u1d5a\u1d58\u0003\u0002", + "\u0002\u0002\u1d5b\u1d5e\u0003\u0002\u0002\u0002\u1d5c\u1d5a\u0003\u0002", + "\u0002\u0002\u1d5c\u1d5d\u0003\u0002\u0002\u0002\u1d5d\u036d\u0003\u0002", + "\u0002\u0002\u1d5e\u1d5c\u0003\u0002\u0002\u0002\u1d5f\u1d62\u0005\u036c", + "\u01b7\u0002\u1d60\u1d62\u0003\u0002\u0002\u0002\u1d61\u1d5f\u0003\u0002", + "\u0002\u0002\u1d61\u1d60\u0003\u0002\u0002\u0002\u1d62\u036f\u0003\u0002", + "\u0002\u0002\u1d63\u1d64\u0007\u00cd\u0002\u0002\u1d64\u1d74\u0005\u0372", + "\u01ba\u0002\u1d65\u1d66\u0007\u00cd\u0002\u0002\u1d66\u1d67\u0005\u0358", + "\u01ad\u0002\u1d67\u1d68\u0005\u0362\u01b2\u0002\u1d68\u1d69\u0005\u0372", + "\u01ba\u0002\u1d69\u1d74\u0003\u0002\u0002\u0002\u1d6a\u1d6b\u0007\u00cd", + "\u0002\u0002\u1d6b\u1d6c\u0007\u0082\u0002\u0002\u1d6c\u1d74\u0005\u0372", + "\u01ba\u0002\u1d6d\u1d6e\u0007\u00cd\u0002\u0002\u1d6e\u1d6f\u0007\u0004", + "\u0002\u0002\u1d6f\u1d70\u0005\u0374\u01bb\u0002\u1d70\u1d71\u0007\u0005", + "\u0002\u0002\u1d71\u1d72\u0005\u0372\u01ba\u0002\u1d72\u1d74\u0003\u0002", + "\u0002\u0002\u1d73\u1d63\u0003\u0002\u0002\u0002\u1d73\u1d65\u0003\u0002", + "\u0002\u0002\u1d73\u1d6a\u0003\u0002\u0002\u0002\u1d73\u1d6d\u0003\u0002", + "\u0002\u0002\u1d74\u0371\u0003\u0002\u0002\u0002\u1d75\u1d7f\u0005\u03ba", + "\u01de\u0002\u1d76\u1d7f\u0005\u0388\u01c5\u0002\u1d77\u1d7f\u0005\u03a8", + "\u01d5\u0002\u1d78\u1d7f\u0005\u039a\u01ce\u0002\u1d79\u1d7f\u0005\u03b2", + "\u01da\u0002\u1d7a\u1d7f\u0005\u010a\u0086\u0002\u1d7b\u1d7f\u0005\u0110", + "\u0089\u0002\u1d7c\u1d7f\u0005\u0116\u008c\u0002\u1d7d\u1d7f\u0005\u0382", + "\u01c2\u0002\u1d7e\u1d75\u0003\u0002\u0002\u0002\u1d7e\u1d76\u0003\u0002", + "\u0002\u0002\u1d7e\u1d77\u0003\u0002\u0002\u0002\u1d7e\u1d78\u0003\u0002", + "\u0002\u0002\u1d7e\u1d79\u0003\u0002\u0002\u0002\u1d7e\u1d7a\u0003\u0002", + "\u0002\u0002\u1d7e\u1d7b\u0003\u0002\u0002\u0002\u1d7e\u1d7c\u0003\u0002", + "\u0002\u0002\u1d7e\u1d7d\u0003\u0002\u0002\u0002\u1d7f\u0373\u0003\u0002", + "\u0002\u0002\u1d80\u1d85\u0005\u0376\u01bc\u0002\u1d81\u1d82\u0007\b", + "\u0002\u0002\u1d82\u1d84\u0005\u0376\u01bc\u0002\u1d83\u1d81\u0003\u0002", + "\u0002\u0002\u1d84\u1d87\u0003\u0002\u0002\u0002\u1d85\u1d83\u0003\u0002", + "\u0002\u0002\u1d85\u1d86\u0003\u0002\u0002\u0002\u1d86\u0375\u0003\u0002", + "\u0002\u0002\u1d87\u1d85\u0003\u0002\u0002\u0002\u1d88\u1d89\u0005\u0378", + "\u01bd\u0002\u1d89\u1d8a\u0005\u037a\u01be\u0002\u1d8a\u0377\u0003\u0002", + "\u0002\u0002\u1d8b\u1d8e\u0005\u0556\u02ac\u0002\u1d8c\u1d8e\u0005\u0358", + "\u01ad\u0002\u1d8d\u1d8b\u0003\u0002\u0002\u0002\u1d8d\u1d8c\u0003\u0002", + "\u0002\u0002\u1d8e\u0379\u0003\u0002\u0002\u0002\u1d8f\u1d93\u0005D", + "#\u0002\u1d90\u1d93\u0005\u0126\u0094\u0002\u1d91\u1d93\u0003\u0002", + "\u0002\u0002\u1d92\u1d8f\u0003\u0002\u0002\u0002\u1d92\u1d90\u0003\u0002", + "\u0002\u0002\u1d92\u1d91\u0003\u0002\u0002\u0002\u1d93\u037b\u0003\u0002", + "\u0002\u0002\u1d94\u1d95\u0007\u011b\u0002\u0002\u1d95\u1d96\u0005\u0532", + "\u029a\u0002\u1d96\u1d97\u0005\u037e\u01c0\u0002\u1d97\u1d98\u0007&", + "\u0002\u0002\u1d98\u1d99\u0005\u0380\u01c1\u0002\u1d99\u037d\u0003\u0002", + "\u0002\u0002\u1d9a\u1d9b\u0007\u0004\u0002\u0002\u1d9b\u1d9c\u0005\u04fc", + "\u027f\u0002\u1d9c\u1d9d\u0007\u0005\u0002\u0002\u1d9d\u1da0\u0003\u0002", + "\u0002\u0002\u1d9e\u1da0\u0003\u0002\u0002\u0002\u1d9f\u1d9a\u0003\u0002", + "\u0002\u0002\u1d9f\u1d9e\u0003\u0002\u0002\u0002\u1da0\u037f\u0003\u0002", + "\u0002\u0002\u1da1\u1da6\u0005\u03ba\u01de\u0002\u1da2\u1da6\u0005\u0388", + "\u01c5\u0002\u1da3\u1da6\u0005\u03a8\u01d5\u0002\u1da4\u1da6\u0005\u039a", + "\u01ce\u0002\u1da5\u1da1\u0003\u0002\u0002\u0002\u1da5\u1da2\u0003\u0002", + "\u0002\u0002\u1da5\u1da3\u0003\u0002\u0002\u0002\u1da5\u1da4\u0003\u0002", + "\u0002\u0002\u1da6\u0381\u0003\u0002\u0002\u0002\u1da7\u1da8\u0007\u00cc", + "\u0002\u0002\u1da8\u1da9\u0005\u0532\u029a\u0002\u1da9\u1daa\u0005\u0384", + "\u01c3\u0002\u1daa\u1dc3\u0003\u0002\u0002\u0002\u1dab\u1dac\u00070", + "\u0002\u0002\u1dac\u1dad\u0005\u00b0Y\u0002\u1dad\u1dae\u0007^\u0002", + "\u0002\u1dae\u1daf\u0005\u010c\u0087\u0002\u1daf\u1db0\u0007&\u0002", + "\u0002\u1db0\u1db1\u0007\u00cc\u0002\u0002\u1db1\u1db2\u0005\u0532\u029a", + "\u0002\u1db2\u1db3\u0005\u0384\u01c3\u0002\u1db3\u1db4\u0005\u010e\u0088", + "\u0002\u1db4\u1dc3\u0003\u0002\u0002\u0002\u1db5\u1db6\u00070\u0002", + "\u0002\u1db6\u1db7\u0005\u00b0Y\u0002\u1db7\u1db8\u0007^\u0002\u0002", + "\u1db8\u1db9\u0007\u00de\u0002\u0002\u1db9\u1dba\u0007O\u0002\u0002", + "\u1dba\u1dbb\u0007\u0185\u0002\u0002\u1dbb\u1dbc\u0005\u010c\u0087\u0002", + "\u1dbc\u1dbd\u0007&\u0002\u0002\u1dbd\u1dbe\u0007\u00cc\u0002\u0002", + "\u1dbe\u1dbf\u0005\u0532\u029a\u0002\u1dbf\u1dc0\u0005\u0384\u01c3\u0002", + "\u1dc0\u1dc1\u0005\u010e\u0088\u0002\u1dc1\u1dc3\u0003\u0002\u0002\u0002", + "\u1dc2\u1da7\u0003\u0002\u0002\u0002\u1dc2\u1dab\u0003\u0002\u0002\u0002", + "\u1dc2\u1db5\u0003\u0002\u0002\u0002\u1dc3\u0383\u0003\u0002\u0002\u0002", + "\u1dc4\u1dc5\u0007\u0004\u0002\u0002\u1dc5\u1dc6\u0005\u04f6\u027c\u0002", + "\u1dc6\u1dc7\u0007\u0005\u0002\u0002\u1dc7\u1dca\u0003\u0002\u0002\u0002", + "\u1dc8\u1dca\u0003\u0002\u0002\u0002\u1dc9\u1dc4\u0003\u0002\u0002\u0002", + "\u1dc9\u1dc8\u0003\u0002\u0002\u0002\u1dca\u0385\u0003\u0002\u0002\u0002", + "\u1dcb\u1dcc\u0007\u00b3\u0002\u0002\u1dcc\u1dd6\u0005\u0532\u029a\u0002", + "\u1dcd\u1dce\u0007\u00b3\u0002\u0002\u1dce\u1dcf\u0007\u011b\u0002\u0002", + "\u1dcf\u1dd6\u0005\u0532\u029a\u0002\u1dd0\u1dd1\u0007\u00b3\u0002\u0002", + "\u1dd1\u1dd6\u0007 \u0002\u0002\u1dd2\u1dd3\u0007\u00b3\u0002\u0002", + "\u1dd3\u1dd4\u0007\u011b\u0002\u0002\u1dd4\u1dd6\u0007 \u0002\u0002", + "\u1dd5\u1dcb\u0003\u0002\u0002\u0002\u1dd5\u1dcd\u0003\u0002\u0002\u0002", + "\u1dd5\u1dd0\u0003\u0002\u0002\u0002\u1dd5\u1dd2\u0003\u0002\u0002\u0002", + "\u1dd6\u0387\u0003\u0002\u0002\u0002\u1dd7\u1dd8\u0005\u03d0\u01e9\u0002", + "\u1dd8\u1dd9\u0007\u00ea\u0002\u0002\u1dd9\u1dda\u0007I\u0002\u0002", + "\u1dda\u1ddb\u0005\u038a\u01c6\u0002\u1ddb\u1ddc\u0005\u038c\u01c7\u0002", + "\u1ddc\u1ddd\u0005\u0394\u01cb\u0002\u1ddd\u1dde\u0005\u0398\u01cd\u0002", + "\u1dde\u0389\u0003\u0002\u0002\u0002\u1ddf\u1de2\u0005\u052e\u0298\u0002", + "\u1de0\u1de1\u0007&\u0002\u0002\u1de1\u1de3\u0005\u0552\u02aa\u0002", + "\u1de2\u1de0\u0003\u0002\u0002\u0002\u1de2\u1de3\u0003\u0002\u0002\u0002", + "\u1de3\u038b\u0003\u0002\u0002\u0002\u1de4\u1df8\u0005\u03ba\u01de\u0002", + "\u1de5\u1de6\u0007\u01c8\u0002\u0002\u1de6\u1de7\u0005\u038e\u01c8\u0002", + "\u1de7\u1de8\u0007\u01bb\u0002\u0002\u1de8\u1de9\u0005\u03ba\u01de\u0002", + "\u1de9\u1df8\u0003\u0002\u0002\u0002\u1dea\u1deb\u0007\u0004\u0002\u0002", + "\u1deb\u1dec\u0005\u0390\u01c9\u0002\u1dec\u1df1\u0007\u0005\u0002\u0002", + "\u1ded\u1dee\u0007\u01c8\u0002\u0002\u1dee\u1def\u0005\u038e\u01c8\u0002", + "\u1def\u1df0\u0007\u01bb\u0002\u0002\u1df0\u1df2\u0003\u0002\u0002\u0002", + "\u1df1\u1ded\u0003\u0002\u0002\u0002\u1df1\u1df2\u0003\u0002\u0002\u0002", + "\u1df2\u1df3\u0003\u0002\u0002\u0002\u1df3\u1df4\u0005\u03ba\u01de\u0002", + "\u1df4\u1df8\u0003\u0002\u0002\u0002\u1df5\u1df6\u00077\u0002\u0002", + "\u1df6\u1df8\u0007\u019f\u0002\u0002\u1df7\u1de4\u0003\u0002\u0002\u0002", + "\u1df7\u1de5\u0003\u0002\u0002\u0002\u1df7\u1dea\u0003\u0002\u0002\u0002", + "\u1df7\u1df5\u0003\u0002\u0002\u0002\u1df8\u038d\u0003\u0002\u0002\u0002", + "\u1df9\u1dfa\t#\u0002\u0002\u1dfa\u038f\u0003\u0002\u0002\u0002\u1dfb", + "\u1e00\u0005\u0392\u01ca\u0002\u1dfc\u1dfd\u0007\b\u0002\u0002\u1dfd", + "\u1dff\u0005\u0392\u01ca\u0002\u1dfe\u1dfc\u0003\u0002\u0002\u0002\u1dff", + "\u1e02\u0003\u0002\u0002\u0002\u1e00\u1dfe\u0003\u0002\u0002\u0002\u1e00", + "\u1e01\u0003\u0002\u0002\u0002\u1e01\u0391\u0003\u0002\u0002\u0002\u1e02", + "\u1e00\u0003\u0002\u0002\u0002\u1e03\u1e04\u0005\u0552\u02aa\u0002\u1e04", + "\u1e05\u0005\u0524\u0293\u0002\u1e05\u0393\u0003\u0002\u0002\u0002\u1e06", + "\u1e07\u0007R\u0002\u0002\u1e07\u1e08\u0007\u01c9\u0002\u0002\u1e08", + "\u1e09\u0005\u0396\u01cc\u0002\u1e09\u1e10\u0007;\u0002\u0002\u1e0a", + "\u1e0b\u0007\u016a\u0002\u0002\u1e0b\u1e0c\u0007\u0146\u0002\u0002\u1e0c", + "\u1e0d\u0005\u03aa\u01d6\u0002\u1e0d\u1e0e\u0005\u043e\u0220\u0002\u1e0e", + "\u1e11\u0003\u0002\u0002\u0002\u1e0f\u1e11\u0007\u0107\u0002\u0002\u1e10", + "\u1e0a\u0003\u0002\u0002\u0002\u1e10\u1e0f\u0003\u0002\u0002\u0002\u1e11", + "\u1e14\u0003\u0002\u0002\u0002\u1e12\u1e14\u0003\u0002\u0002\u0002\u1e13", + "\u1e06\u0003\u0002\u0002\u0002\u1e13\u1e12\u0003\u0002\u0002\u0002\u1e14", + "\u0395\u0003\u0002\u0002\u0002\u1e15\u1e16\u0007\u0004\u0002\u0002\u1e16", + "\u1e17\u0005\u0258\u012d\u0002\u1e17\u1e18\u0007\u0005\u0002\u0002\u1e18", + "\u1e19\u0005\u043e\u0220\u0002\u1e19\u1e1f\u0003\u0002\u0002\u0002\u1e1a", + "\u1e1b\u0007R\u0002\u0002\u1e1b\u1e1c\u0007/\u0002\u0002\u1e1c\u1e1f", + "\u0005\u0532\u029a\u0002\u1e1d\u1e1f\u0003\u0002\u0002\u0002\u1e1e\u1e15", + "\u0003\u0002\u0002\u0002\u1e1e\u1e1a\u0003\u0002\u0002\u0002\u1e1e\u1e1d", + "\u0003\u0002\u0002\u0002\u1e1f\u0397\u0003\u0002\u0002\u0002\u1e20\u1e21", + "\u0007Y\u0002\u0002\u1e21\u1e24\u0005\u0528\u0295\u0002\u1e22\u1e24", + "\u0003\u0002\u0002\u0002\u1e23\u1e20\u0003\u0002\u0002\u0002\u1e23\u1e22", + "\u0003\u0002\u0002\u0002\u1e24\u0399\u0003\u0002\u0002\u0002\u1e25\u1e26", + "\u0005\u03d0\u01e9\u0002\u1e26\u1e27\u0007\u00b8\u0002\u0002\u1e27\u1e28", + "\u0007B\u0002\u0002\u1e28\u1e29\u0005\u042e\u0218\u0002\u1e29\u1e2a", + "\u0005\u039c\u01cf\u0002\u1e2a\u1e2b\u0005\u0440\u0221\u0002\u1e2b\u1e2c", + "\u0005\u0398\u01cd\u0002\u1e2c\u039b\u0003\u0002\u0002\u0002\u1e2d\u1e2e", + "\u0007f\u0002\u0002\u1e2e\u1e31\u0005\u041c\u020f\u0002\u1e2f\u1e31", + "\u0003\u0002\u0002\u0002\u1e30\u1e2d\u0003\u0002\u0002\u0002\u1e30\u1e2f", + "\u0003\u0002\u0002\u0002\u1e31\u039d\u0003\u0002\u0002\u0002\u1e32\u1e33", + "\u0007\u00f9\u0002\u0002\u1e33\u1e34\u0005\u03d8\u01ed\u0002\u1e34\u1e35", + "\u0005\u042c\u0217\u0002\u1e35\u1e36\u0005\u03a0\u01d1\u0002\u1e36\u1e37", + "\u0005\u03a4\u01d3\u0002\u1e37\u039f\u0003\u0002\u0002\u0002\u1e38\u1e39", + "\u0007F\u0002\u0002\u1e39\u1e3a\u0005\u03a2\u01d2\u0002\u1e3a\u1e3b", + "\u0007\u0100\u0002\u0002\u1e3b\u1e3e\u0003\u0002\u0002\u0002\u1e3c\u1e3e", + "\u0003\u0002\u0002\u0002\u1e3d\u1e38\u0003\u0002\u0002\u0002\u1e3d\u1e3c", + "\u0003\u0002\u0002\u0002\u1e3e\u03a1\u0003\u0002\u0002\u0002\u1e3f\u1e40", + "\u0007\u0085\u0002\u0002\u1e40\u1e4c\t$\u0002\u0002\u1e41\u1e42\u0007", + "\u0197\u0002\u0002\u1e42\u1e4c\t$\u0002\u0002\u1e43\u1e48\u0007\u0147", + "\u0002\u0002\u1e44\u1e45\u0007\u016a\u0002\u0002\u1e45\u1e49\u0007\u00cb", + "\u0002\u0002\u1e46\u1e47\u0007\u0197\u0002\u0002\u1e47\u1e49\u0007\u00cb", + "\u0002\u0002\u1e48\u1e44\u0003\u0002\u0002\u0002\u1e48\u1e46\u0003\u0002", + "\u0002\u0002\u1e48\u1e49\u0003\u0002\u0002\u0002\u1e49\u1e4c\u0003\u0002", + "\u0002\u0002\u1e4a\u1e4c\u0007\u00cb\u0002\u0002\u1e4b\u1e3f\u0003\u0002", + "\u0002\u0002\u1e4b\u1e41\u0003\u0002\u0002\u0002\u1e4b\u1e43\u0003\u0002", + "\u0002\u0002\u1e4b\u1e4a\u0003\u0002\u0002\u0002\u1e4c\u03a3\u0003\u0002", + "\u0002\u0002\u1e4d\u1e50\u0007\u0109\u0002\u0002\u1e4e\u1e50\u0003\u0002", + "\u0002\u0002\u1e4f\u1e4d\u0003\u0002\u0002\u0002\u1e4f\u1e4e\u0003\u0002", + "\u0002\u0002\u1e50\u03a5\u0003\u0002\u0002\u0002\u1e51\u1e56\u0007\u0109", + "\u0002\u0002\u1e52\u1e53\u0007\u01ca\u0002\u0002\u1e53\u1e56\u0007\u01cb", + "\u0002\u0002\u1e54\u1e56\u0003\u0002\u0002\u0002\u1e55\u1e51\u0003\u0002", + "\u0002\u0002\u1e55\u1e52\u0003\u0002\u0002\u0002\u1e55\u1e54\u0003\u0002", + "\u0002\u0002\u1e56\u03a7\u0003\u0002\u0002\u0002\u1e57\u1e58\u0005\u03d0", + "\u01e9\u0002\u1e58\u1e59\u0007\u016a\u0002\u0002\u1e59\u1e5a\u0005\u042e", + "\u0218\u0002\u1e5a\u1e5b\u0007\u0146\u0002\u0002\u1e5b\u1e5c\u0005\u03aa", + "\u01d6\u0002\u1e5c\u1e5d\u0005\u041a\u020e\u0002\u1e5d\u1e5e\u0005\u0440", + "\u0221\u0002\u1e5e\u1e5f\u0005\u0398\u01cd\u0002\u1e5f\u03a9\u0003\u0002", + "\u0002\u0002\u1e60\u1e65\u0005\u03ac\u01d7\u0002\u1e61\u1e62\u0007\b", + "\u0002\u0002\u1e62\u1e64\u0005\u03ac\u01d7\u0002\u1e63\u1e61\u0003\u0002", + "\u0002\u0002\u1e64\u1e67\u0003\u0002\u0002\u0002\u1e65\u1e63\u0003\u0002", + "\u0002\u0002\u1e65\u1e66\u0003\u0002\u0002\u0002\u1e66\u03ab\u0003\u0002", + "\u0002\u0002\u1e67\u1e65\u0003\u0002\u0002\u0002\u1e68\u1e69\u0005\u03ae", + "\u01d8\u0002\u1e69\u1e6a\u0007\f\u0002\u0002\u1e6a\u1e6b\u0005\u0482", + "\u0242\u0002\u1e6b\u1e73\u0003\u0002\u0002\u0002\u1e6c\u1e6d\u0007\u0004", + "\u0002\u0002\u1e6d\u1e6e\u0005\u03b0\u01d9\u0002\u1e6e\u1e6f\u0007\u0005", + "\u0002\u0002\u1e6f\u1e70\u0007\f\u0002\u0002\u1e70\u1e71\u0005\u0482", + "\u0242\u0002\u1e71\u1e73\u0003\u0002\u0002\u0002\u1e72\u1e68\u0003\u0002", + "\u0002\u0002\u1e72\u1e6c\u0003\u0002\u0002\u0002\u1e73\u03ad\u0003\u0002", + "\u0002\u0002\u1e74\u1e75\u0005\u0552\u02aa\u0002\u1e75\u1e76\u0005\u0524", + "\u0293\u0002\u1e76\u03af\u0003\u0002\u0002\u0002\u1e77\u1e7c\u0005\u03ae", + "\u01d8\u0002\u1e78\u1e79\u0007\b\u0002\u0002\u1e79\u1e7b\u0005\u03ae", + "\u01d8\u0002\u1e7a\u1e78\u0003\u0002\u0002\u0002\u1e7b\u1e7e\u0003\u0002", + "\u0002\u0002\u1e7c\u1e7a\u0003\u0002\u0002\u0002\u1e7c\u1e7d\u0003\u0002", + "\u0002\u0002\u1e7d\u03b1\u0003\u0002\u0002\u0002\u1e7e\u1e7c\u0003\u0002", + "\u0002\u0002\u1e7f\u1e80\u0007\u00b4\u0002\u0002\u1e80\u1e81\u0005\u03b4", + "\u01db\u0002\u1e81\u1e82\u0005\u03b6\u01dc\u0002\u1e82\u1e83\u0007\u00ae", + "\u0002\u0002\u1e83\u1e84\u0005\u03b8\u01dd\u0002\u1e84\u1e85\u0007@", + "\u0002\u0002\u1e85\u1e86\u0005\u03ba\u01de\u0002\u1e86\u03b3\u0003\u0002", + "\u0002\u0002\u1e87\u1e88\u0005\u0532\u029a\u0002\u1e88\u03b5\u0003\u0002", + "\u0002\u0002\u1e89\u1e8a\u0007\u0106\u0002\u0002\u1e8a\u1e8f\u0007\u013d", + "\u0002\u0002\u1e8b\u1e8f\u0007\u013d\u0002\u0002\u1e8c\u1e8f\u0007m", + "\u0002\u0002\u1e8d\u1e8f\u0007\u00e9\u0002\u0002\u1e8e\u1e89\u0003\u0002", + "\u0002\u0002\u1e8e\u1e8b\u0003\u0002\u0002\u0002\u1e8e\u1e8c\u0003\u0002", + "\u0002\u0002\u1e8e\u1e8d\u0003\u0002\u0002\u0002\u1e8f\u1e92\u0003\u0002", + "\u0002\u0002\u1e90\u1e8e\u0003\u0002\u0002\u0002\u1e90\u1e91\u0003\u0002", + "\u0002\u0002\u1e91\u03b7\u0003\u0002\u0002\u0002\u1e92\u1e90\u0003\u0002", + "\u0002\u0002\u1e93\u1e99\u0003\u0002\u0002\u0002\u1e94\u1e95\u0007k", + "\u0002\u0002\u1e95\u1e99\u0007\u00db\u0002\u0002\u1e96\u1e97\u0007\u0174", + "\u0002\u0002\u1e97\u1e99\u0007\u00db\u0002\u0002\u1e98\u1e93\u0003\u0002", + "\u0002\u0002\u1e98\u1e94\u0003\u0002\u0002\u0002\u1e98\u1e96\u0003\u0002", + "\u0002\u0002\u1e99\u03b9\u0003\u0002\u0002\u0002\u1e9a\u1e9d\u0005\u03be", + "\u01e0\u0002\u1e9b\u1e9d\u0005\u03bc\u01df\u0002\u1e9c\u1e9a\u0003\u0002", + "\u0002\u0002\u1e9c\u1e9b\u0003\u0002\u0002\u0002\u1e9d\u03bb\u0003\u0002", + "\u0002\u0002\u1e9e\u1e9f\u0007\u0004\u0002\u0002\u1e9f\u1ea0\u0005\u03be", + "\u01e0\u0002\u1ea0\u1ea1\u0007\u0005\u0002\u0002\u1ea1\u1ea7\u0003\u0002", + "\u0002\u0002\u1ea2\u1ea3\u0007\u0004\u0002\u0002\u1ea3\u1ea4\u0005\u03bc", + "\u01df\u0002\u1ea4\u1ea5\u0007\u0005\u0002\u0002\u1ea5\u1ea7\u0003\u0002", + "\u0002\u0002\u1ea6\u1e9e\u0003\u0002\u0002\u0002\u1ea6\u1ea2\u0003\u0002", + "\u0002\u0002\u1ea7\u03bd\u0003\u0002\u0002\u0002\u1ea8\u1ea9\u0005\u03c0", + "\u01e1\u0002\u1ea9\u1eb0\u0005\u03e0\u01f1\u0002\u1eaa\u1eab\u0005\u040c", + "\u0207\u0002\u1eab\u1eac\u0005\u03ea\u01f6\u0002\u1eac\u1eb1\u0003\u0002", + "\u0002\u0002\u1ead\u1eae\u0005\u03e8\u01f5\u0002\u1eae\u1eaf\u0005\u040e", + "\u0208\u0002\u1eaf\u1eb1\u0003\u0002\u0002\u0002\u1eb0\u1eaa\u0003\u0002", + "\u0002\u0002\u1eb0\u1ead\u0003\u0002\u0002\u0002\u1eb0\u1eb1\u0003\u0002", + "\u0002\u0002\u1eb1\u1ebe\u0003\u0002\u0002\u0002\u1eb2\u1eb3\u0005\u03c8", + "\u01e5\u0002\u1eb3\u1eb4\u0005\u03c0\u01e1\u0002\u1eb4\u1ebb\u0005\u03e0", + "\u01f1\u0002\u1eb5\u1eb6\u0005\u040c\u0207\u0002\u1eb6\u1eb7\u0005\u03ea", + "\u01f6\u0002\u1eb7\u1ebc\u0003\u0002\u0002\u0002\u1eb8\u1eb9\u0005\u03e8", + "\u01f5\u0002\u1eb9\u1eba\u0005\u040e\u0208\u0002\u1eba\u1ebc\u0003\u0002", + "\u0002\u0002\u1ebb\u1eb5\u0003\u0002\u0002\u0002\u1ebb\u1eb8\u0003\u0002", + "\u0002\u0002\u1ebb\u1ebc\u0003\u0002\u0002\u0002\u1ebc\u1ebe\u0003\u0002", + "\u0002\u0002\u1ebd\u1ea8\u0003\u0002\u0002\u0002\u1ebd\u1eb2\u0003\u0002", + "\u0002\u0002\u1ebe\u03bf\u0003\u0002\u0002\u0002\u1ebf\u1ec2\u0005\u03c2", + "\u01e2\u0002\u1ec0\u1ec2\u0005\u03bc\u01df\u0002\u1ec1\u1ebf\u0003\u0002", + "\u0002\u0002\u1ec1\u1ec0\u0003\u0002\u0002\u0002\u1ec2\u03c1\u0003\u0002", + "\u0002\u0002\u1ec3\u1ecb\u0007Z\u0002\u0002\u1ec4\u1ec5\u0005\u03de", + "\u01f0\u0002\u1ec5\u1ec6\u0005\u03d2\u01ea\u0002\u1ec6\u1ec7\u0005\u0526", + "\u0294\u0002\u1ec7\u1ecc\u0003\u0002\u0002\u0002\u1ec8\u1ec9\u0005\u03dc", + "\u01ef\u0002\u1ec9\u1eca\u0005\u0528\u0295\u0002\u1eca\u1ecc\u0003\u0002", + "\u0002\u0002\u1ecb\u1ec4\u0003\u0002\u0002\u0002\u1ecb\u1ec8\u0003\u0002", + "\u0002\u0002\u1ecc\u1ecd\u0003\u0002\u0002\u0002\u1ecd\u1ece\u0005\u03d2", + "\u01ea\u0002\u1ece\u1ecf\u0005\u041a\u020e\u0002\u1ecf\u1ed0\u0005\u043e", + "\u0220\u0002\u1ed0\u1ed1\u0005\u03fc\u01ff\u0002\u1ed1\u1ed2\u0005\u040a", + "\u0206\u0002\u1ed2\u1ed3\u0005\u04ce\u0268\u0002\u1ed3\u1ede\u0003\u0002", + "\u0002\u0002\u1ed4\u1ede\u0005\u0418\u020d\u0002\u1ed5\u1ed6\u0007^", + "\u0002\u0002\u1ed6\u1ede\u0005\u042a\u0216\u0002\u1ed7\u1ed8\u0005\u03bc", + "\u01df\u0002\u1ed8\u1edb\u0005\u03c6\u01e4\u0002\u1ed9\u1edc\u0005\u03c2", + "\u01e2\u0002\u1eda\u1edc\u0005\u03bc\u01df\u0002\u1edb\u1ed9\u0003\u0002", + "\u0002\u0002\u1edb\u1eda\u0003\u0002\u0002\u0002\u1edc\u1ede\u0003\u0002", + "\u0002\u0002\u1edd\u1ec3\u0003\u0002\u0002\u0002\u1edd\u1ed4\u0003\u0002", + "\u0002\u0002\u1edd\u1ed5\u0003\u0002\u0002\u0002\u1edd\u1ed7\u0003\u0002", + "\u0002\u0002\u1ede\u1ee6\u0003\u0002\u0002\u0002\u1edf\u1ee2\u0005\u03c6", + "\u01e4\u0002\u1ee0\u1ee3\u0005\u03c2\u01e2\u0002\u1ee1\u1ee3\u0005\u03bc", + "\u01df\u0002\u1ee2\u1ee0\u0003\u0002\u0002\u0002\u1ee2\u1ee1\u0003\u0002", + "\u0002\u0002\u1ee3\u1ee5\u0003\u0002\u0002\u0002\u1ee4\u1edf\u0003\u0002", + "\u0002\u0002\u1ee5\u1ee8\u0003\u0002\u0002\u0002\u1ee6\u1ee4\u0003\u0002", + "\u0002\u0002\u1ee6\u1ee7\u0003\u0002\u0002\u0002\u1ee7\u03c3\u0003\u0002", + "\u0002\u0002\u1ee8\u1ee6\u0003\u0002\u0002\u0002\u1ee9\u1eed\u0007c", + "\u0002\u0002\u1eea\u1eed\u0007H\u0002\u0002\u1eeb\u1eed\u0007=\u0002", + "\u0002\u1eec\u1ee9\u0003\u0002\u0002\u0002\u1eec\u1eea\u0003\u0002\u0002", + "\u0002\u1eec\u1eeb\u0003\u0002\u0002\u0002\u1eed\u03c5\u0003\u0002\u0002", + "\u0002\u1eee\u1eef\u0005\u03c4\u01e3\u0002\u1eef\u1ef0\u0005\u03da\u01ee", + "\u0002\u1ef0\u03c7\u0003\u0002\u0002\u0002\u1ef1\u1ef3\u0007k\u0002", + "\u0002\u1ef2\u1ef4\u0007\u0128\u0002\u0002\u1ef3\u1ef2\u0003\u0002\u0002", + "\u0002\u1ef3\u1ef4\u0003\u0002\u0002\u0002\u1ef4\u1ef5\u0003\u0002\u0002", + "\u0002\u1ef5\u1ef6\u0005\u03ca\u01e6\u0002\u1ef6\u03c9\u0003\u0002\u0002", + "\u0002\u1ef7\u1efc\u0005\u03cc\u01e7\u0002\u1ef8\u1ef9\u0007\b\u0002", + "\u0002\u1ef9\u1efb\u0005\u03cc\u01e7\u0002\u1efa\u1ef8\u0003\u0002\u0002", + "\u0002\u1efb\u1efe\u0003\u0002\u0002\u0002\u1efc\u1efa\u0003\u0002\u0002", + "\u0002\u1efc\u1efd\u0003\u0002\u0002\u0002\u1efd\u03cb\u0003\u0002\u0002", + "\u0002\u1efe\u1efc\u0003\u0002\u0002\u0002\u1eff\u1f00\u0005\u0532\u029a", + "\u0002\u1f00\u1f01\u0005\u0368\u01b5\u0002\u1f01\u1f02\u0007&\u0002", + "\u0002\u1f02\u1f03\u0005\u03ce\u01e8\u0002\u1f03\u1f04\u0007\u0004\u0002", + "\u0002\u1f04\u1f05\u0005\u0380\u01c1\u0002\u1f05\u1f06\u0007\u0005\u0002", + "\u0002\u1f06\u03cd\u0003\u0002\u0002\u0002\u1f07\u1f0c\u0007\u00fc\u0002", + "\u0002\u1f08\u1f09\u0007O\u0002\u0002\u1f09\u1f0c\u0007\u00fc\u0002", + "\u0002\u1f0a\u1f0c\u0003\u0002\u0002\u0002\u1f0b\u1f07\u0003\u0002\u0002", + "\u0002\u1f0b\u1f08\u0003\u0002\u0002\u0002\u1f0b\u1f0a\u0003\u0002\u0002", + "\u0002\u1f0c\u03cf\u0003\u0002\u0002\u0002\u1f0d\u1f10\u0005\u03c8\u01e5", + "\u0002\u1f0e\u1f10\u0003\u0002\u0002\u0002\u1f0f\u1f0d\u0003\u0002\u0002", + "\u0002\u1f0f\u1f0e\u0003\u0002\u0002\u0002\u1f10\u03d1\u0003\u0002\u0002", + "\u0002\u1f11\u1f16\u0007I\u0002\u0002\u1f12\u1f13\u0005\u03d4\u01eb", + "\u0002\u1f13\u1f14\u0005\u03d6\u01ec\u0002\u1f14\u1f17\u0003\u0002\u0002", + "\u0002\u1f15\u1f17\u0005\u0610\u0309\u0002\u1f16\u1f12\u0003\u0002\u0002", + "\u0002\u1f16\u1f15\u0003\u0002\u0002\u0002\u1f17\u1f1a\u0003\u0002\u0002", + "\u0002\u1f18\u1f1a\u0003\u0002\u0002\u0002\u1f19\u1f11\u0003\u0002\u0002", + "\u0002\u1f19\u1f18\u0003\u0002\u0002\u0002\u1f1a\u03d3\u0003\u0002\u0002", + "\u0002\u1f1b\u1f1e\u0003\u0002\u0002\u0002\u1f1c\u1f1e\u0007\u0153\u0002", + "\u0002\u1f1d\u1f1b\u0003\u0002\u0002\u0002\u1f1d\u1f1c\u0003\u0002\u0002", + "\u0002\u1f1e\u03d5\u0003\u0002\u0002\u0002\u1f1f\u1f21\t%\u0002\u0002", + "\u1f20\u1f1f\u0003\u0002\u0002\u0002\u1f20\u1f21\u0003\u0002\u0002\u0002", + "\u1f21\u1f22\u0003\u0002\u0002\u0002\u1f22\u1f23\t\r\u0002\u0002\u1f23", + "\u1f24\u0005\u03d8\u01ed\u0002\u1f24\u1f25\u0005\u052e\u0298\u0002\u1f25", + "\u1f2e\u0003\u0002\u0002\u0002\u1f26\u1f27\u0007\u0168\u0002\u0002\u1f27", + "\u1f28\u0005\u03d8\u01ed\u0002\u1f28\u1f29\u0005\u052e\u0298\u0002\u1f29", + "\u1f2e\u0003\u0002\u0002\u0002\u1f2a\u1f2b\u0007^\u0002\u0002\u1f2b", + "\u1f2e\u0005\u052e\u0298\u0002\u1f2c\u1f2e\u0005\u052e\u0298\u0002\u1f2d", + "\u1f20\u0003\u0002\u0002\u0002\u1f2d\u1f26\u0003\u0002\u0002\u0002\u1f2d", + "\u1f2a\u0003\u0002\u0002\u0002\u1f2d\u1f2c\u0003\u0002\u0002\u0002\u1f2e", + "\u03d7\u0003\u0002\u0002\u0002\u1f2f\u1f32\u0007^\u0002\u0002\u1f30", + "\u1f32\u0003\u0002\u0002\u0002\u1f31\u1f2f\u0003\u0002\u0002\u0002\u1f31", + "\u1f30\u0003\u0002\u0002\u0002\u1f32\u03d9\u0003\u0002\u0002\u0002\u1f33", + "\u1f37\u0007 \u0002\u0002\u1f34\u1f37\u0007:\u0002\u0002\u1f35\u1f37", + "\u0003\u0002\u0002\u0002\u1f36\u1f33\u0003\u0002\u0002\u0002\u1f36\u1f34", + "\u0003\u0002\u0002\u0002\u1f36\u1f35\u0003\u0002\u0002\u0002\u1f37\u03db", + "\u0003\u0002\u0002\u0002\u1f38\u1f3e\u0007:\u0002\u0002\u1f39\u1f3a", + "\u0007R\u0002\u0002\u1f3a\u1f3b\u0007\u0004\u0002\u0002\u1f3b\u1f3c", + "\u0005\u04f6\u027c\u0002\u1f3c\u1f3d\u0007\u0005\u0002\u0002\u1f3d\u1f3f", + "\u0003\u0002\u0002\u0002\u1f3e\u1f39\u0003\u0002\u0002\u0002\u1f3e\u1f3f", + "\u0003\u0002\u0002\u0002\u1f3f\u03dd\u0003\u0002\u0002\u0002\u1f40\u1f43", + "\u0007 \u0002\u0002\u1f41\u1f43\u0003\u0002\u0002\u0002\u1f42\u1f40", + "\u0003\u0002\u0002\u0002\u1f42\u1f41\u0003\u0002\u0002\u0002\u1f43\u03df", + "\u0003\u0002\u0002\u0002\u1f44\u1f47\u0005\u03e2\u01f2\u0002\u1f45\u1f47", + "\u0003\u0002\u0002\u0002\u1f46\u1f44\u0003\u0002\u0002\u0002\u1f46\u1f45", + "\u0003\u0002\u0002\u0002\u1f47\u03e1\u0003\u0002\u0002\u0002\u1f48\u1f49", + "\u0007U\u0002\u0002\u1f49\u1f4a\u0007\u0095\u0002\u0002\u1f4a\u1f4b", + "\u0005\u03e4\u01f3\u0002\u1f4b\u03e3\u0003\u0002\u0002\u0002\u1f4c\u1f51", + "\u0005\u03e6\u01f4\u0002\u1f4d\u1f4e\u0007\b\u0002\u0002\u1f4e\u1f50", + "\u0005\u03e6\u01f4\u0002\u1f4f\u1f4d\u0003\u0002\u0002\u0002\u1f50\u1f53", + "\u0003\u0002\u0002\u0002\u1f51\u1f4f\u0003\u0002\u0002\u0002\u1f51\u1f52", + "\u0003\u0002\u0002\u0002\u1f52\u03e5\u0003\u0002\u0002\u0002\u1f53\u1f51", + "\u0003\u0002\u0002\u0002\u1f54\u1f58\u0005\u0482\u0242\u0002\u1f55\u1f56", + "\u0007f\u0002\u0002\u1f56\u1f59\u0005\u04f2\u027a\u0002\u1f57\u1f59", + "\u0005\u0266\u0134\u0002\u1f58\u1f55\u0003\u0002\u0002\u0002\u1f58\u1f57", + "\u0003\u0002\u0002\u0002\u1f59\u1f5a\u0003\u0002\u0002\u0002\u1f5a\u1f5b", + "\u0005\u0268\u0135\u0002\u1f5b\u03e7\u0003\u0002\u0002\u0002\u1f5c\u1f5e", + "\u0005\u03ec\u01f7\u0002\u1f5d\u1f5f\u0005\u03ee\u01f8\u0002\u1f5e\u1f5d", + "\u0003\u0002\u0002\u0002\u1f5e\u1f5f\u0003\u0002\u0002\u0002\u1f5f\u1f65", + "\u0003\u0002\u0002\u0002\u1f60\u1f62\u0005\u03ee\u01f8\u0002\u1f61\u1f63", + "\u0005\u03ec\u01f7\u0002\u1f62\u1f61\u0003\u0002\u0002\u0002\u1f62\u1f63", + "\u0003\u0002\u0002\u0002\u1f63\u1f65\u0003\u0002\u0002\u0002\u1f64\u1f5c", + "\u0003\u0002\u0002\u0002\u1f64\u1f60\u0003\u0002\u0002\u0002\u1f65\u03e9", + "\u0003\u0002\u0002\u0002\u1f66\u1f69\u0005\u03e8\u01f5\u0002\u1f67\u1f69", + "\u0003\u0002\u0002\u0002\u1f68\u1f66\u0003\u0002\u0002\u0002\u1f68\u1f67", + "\u0003\u0002\u0002\u0002\u1f69\u03eb\u0003\u0002\u0002\u0002\u1f6a\u1f6b", + "\u0007L\u0002\u0002\u1f6b\u1f6e\u0005\u03f0\u01f9\u0002\u1f6c\u1f6d", + "\u0007\b\u0002\u0002\u1f6d\u1f6f\u0005\u03f2\u01fa\u0002\u1f6e\u1f6c", + "\u0003\u0002\u0002\u0002\u1f6e\u1f6f\u0003\u0002\u0002\u0002\u1f6f\u1f82", + "\u0003\u0002\u0002\u0002\u1f70\u1f71\u0007?\u0002\u0002\u1f71\u1f7f", + "\u0005\u03fa\u01fe\u0002\u1f72\u1f73\u0005\u03f4\u01fb\u0002\u1f73\u1f77", + "\u0005\u03f8\u01fd\u0002\u1f74\u1f78\u0007S\u0002\u0002\u1f75\u1f76", + "\u0007k\u0002\u0002\u1f76\u1f78\u0007\u01cc\u0002\u0002\u1f77\u1f74", + "\u0003\u0002\u0002\u0002\u1f77\u1f75\u0003\u0002\u0002\u0002\u1f78\u1f80", + "\u0003\u0002\u0002\u0002\u1f79\u1f7d\u0005\u03f8\u01fd\u0002\u1f7a\u1f7e", + "\u0007S\u0002\u0002\u1f7b\u1f7c\u0007k\u0002\u0002\u1f7c\u1f7e\u0007", + "\u01cc\u0002\u0002\u1f7d\u1f7a\u0003\u0002\u0002\u0002\u1f7d\u1f7b\u0003", + "\u0002\u0002\u0002\u1f7e\u1f80\u0003\u0002\u0002\u0002\u1f7f\u1f72\u0003", + "\u0002\u0002\u0002\u1f7f\u1f79\u0003\u0002\u0002\u0002\u1f80\u1f82\u0003", + "\u0002\u0002\u0002\u1f81\u1f6a\u0003\u0002\u0002\u0002\u1f81\u1f70\u0003", + "\u0002\u0002\u0002\u1f82\u03ed\u0003\u0002\u0002\u0002\u1f83\u1f88\u0007", + "Q\u0002\u0002\u1f84\u1f89\u0005\u03f2\u01fa\u0002\u1f85\u1f86\u0005", + "\u03f4\u01fb\u0002\u1f86\u1f87\u0005\u03f8\u01fd\u0002\u1f87\u1f89\u0003", + "\u0002\u0002\u0002\u1f88\u1f84\u0003\u0002\u0002\u0002\u1f88\u1f85\u0003", + "\u0002\u0002\u0002\u1f89\u03ef\u0003\u0002\u0002\u0002\u1f8a\u1f8d\u0005", + "\u0482\u0242\u0002\u1f8b\u1f8d\u0007 \u0002\u0002\u1f8c\u1f8a\u0003", + "\u0002\u0002\u0002\u1f8c\u1f8b\u0003\u0002\u0002\u0002\u1f8d\u03f1\u0003", + "\u0002\u0002\u0002\u1f8e\u1f8f\u0005\u0482\u0242\u0002\u1f8f\u03f3\u0003", + "\u0002\u0002\u0002\u1f90\u1f96\u0005\u04ac\u0257\u0002\u1f91\u1f92\u0007", + "\u000e\u0002\u0002\u1f92\u1f96\u0005\u03f6\u01fc\u0002\u1f93\u1f94\u0007", + "\u000f\u0002\u0002\u1f94\u1f96\u0005\u03f6\u01fc\u0002\u1f95\u1f90\u0003", + "\u0002\u0002\u0002\u1f95\u1f91\u0003\u0002\u0002\u0002\u1f95\u1f93\u0003", + "\u0002\u0002\u0002\u1f96\u03f5\u0003\u0002\u0002\u0002\u1f97\u1f9a\u0005", + "\u0542\u02a2\u0002\u1f98\u1f9a\u0005\u0540\u02a1\u0002\u1f99\u1f97\u0003", + "\u0002\u0002\u0002\u1f99\u1f98\u0003\u0002\u0002\u0002\u1f9a\u03f7\u0003", + "\u0002\u0002\u0002\u1f9b\u1f9c\t&\u0002\u0002\u1f9c\u03f9\u0003\u0002", + "\u0002\u0002\u1f9d\u1f9e\t\'\u0002\u0002\u1f9e\u03fb\u0003\u0002\u0002", + "\u0002\u1f9f\u1fa0\u0007D\u0002\u0002\u1fa0\u1fa1\u0007\u0095\u0002", + "\u0002\u1fa1\u1fa4\u0005\u03fe\u0200\u0002\u1fa2\u1fa4\u0003\u0002\u0002", + "\u0002\u1fa3\u1f9f\u0003\u0002\u0002\u0002\u1fa3\u1fa2\u0003\u0002\u0002", + "\u0002\u1fa4\u03fd\u0003\u0002\u0002\u0002\u1fa5\u1faa\u0005\u0400\u0201", + "\u0002\u1fa6\u1fa7\u0007\b\u0002\u0002\u1fa7\u1fa9\u0005\u0400\u0201", + "\u0002\u1fa8\u1fa6\u0003\u0002\u0002\u0002\u1fa9\u1fac\u0003\u0002\u0002", + "\u0002\u1faa\u1fa8\u0003\u0002\u0002\u0002\u1faa\u1fab\u0003\u0002\u0002", + "\u0002\u1fab\u03ff\u0003\u0002\u0002\u0002\u1fac\u1faa\u0003\u0002\u0002", + "\u0002\u1fad\u1fb3\u0005\u0482\u0242\u0002\u1fae\u1fb3\u0005\u0402\u0202", + "\u0002\u1faf\u1fb3\u0005\u0406\u0204\u0002\u1fb0\u1fb3\u0005\u0404\u0203", + "\u0002\u1fb1\u1fb3\u0005\u0408\u0205\u0002\u1fb2\u1fad\u0003\u0002\u0002", + "\u0002\u1fb2\u1fae\u0003\u0002\u0002\u0002\u1fb2\u1faf\u0003\u0002\u0002", + "\u0002\u1fb2\u1fb0\u0003\u0002\u0002\u0002\u1fb2\u1fb1\u0003\u0002\u0002", + "\u0002\u1fb3\u0401\u0003\u0002\u0002\u0002\u1fb4\u1fb5\u0007\u0004\u0002", + "\u0002\u1fb5\u1fb6\u0007\u0005\u0002\u0002\u1fb6\u0403\u0003\u0002\u0002", + "\u0002\u1fb7\u1fb8\u0007\u01cd\u0002\u0002\u1fb8\u1fb9\u0007\u0004\u0002", + "\u0002\u1fb9\u1fba\u0005\u04f6\u027c\u0002\u1fba\u1fbb\u0007\u0005\u0002", + "\u0002\u1fbb\u0405\u0003\u0002\u0002\u0002\u1fbc\u1fbd\u0007\u01ce\u0002", + "\u0002\u1fbd\u1fbe\u0007\u0004\u0002\u0002\u1fbe\u1fbf\u0005\u04f6\u027c", + "\u0002\u1fbf\u1fc0\u0007\u0005\u0002\u0002\u1fc0\u0407\u0003\u0002\u0002", + "\u0002\u1fc1\u1fc2\u0007\u01cf\u0002\u0002\u1fc2\u1fc3\u0007\u01d0\u0002", + "\u0002\u1fc3\u1fc4\u0007\u0004\u0002\u0002\u1fc4\u1fc5\u0005\u03fe\u0200", + "\u0002\u1fc5\u1fc6\u0007\u0005\u0002\u0002\u1fc6\u0409\u0003\u0002\u0002", + "\u0002\u1fc7\u1fc8\u0007E\u0002\u0002\u1fc8\u1fcb\u0005\u0482\u0242", + "\u0002\u1fc9\u1fcb\u0003\u0002\u0002\u0002\u1fca\u1fc7\u0003\u0002\u0002", + "\u0002\u1fca\u1fc9\u0003\u0002\u0002\u0002\u1fcb\u040b\u0003\u0002\u0002", + "\u0002\u1fcc\u1fd1\u0005\u0410\u0209\u0002\u1fcd\u1fce\u0007@\u0002", + "\u0002\u1fce\u1fcf\u0007\u0125\u0002\u0002\u1fcf\u1fd1\u0007S\u0002", + "\u0002\u1fd0\u1fcc\u0003\u0002\u0002\u0002\u1fd0\u1fcd\u0003\u0002\u0002", + "\u0002\u1fd1\u040d\u0003\u0002\u0002\u0002\u1fd2\u1fd5\u0005\u040c\u0207", + "\u0002\u1fd3\u1fd5\u0003\u0002\u0002\u0002\u1fd4\u1fd2\u0003\u0002\u0002", + "\u0002\u1fd4\u1fd3\u0003\u0002\u0002\u0002\u1fd5\u040f\u0003\u0002\u0002", + "\u0002\u1fd6\u1fd8\u0005\u0412\u020a\u0002\u1fd7\u1fd6\u0003\u0002\u0002", + "\u0002\u1fd8\u1fd9\u0003\u0002\u0002\u0002\u1fd9\u1fd7\u0003\u0002\u0002", + "\u0002\u1fd9\u1fda\u0003\u0002\u0002\u0002\u1fda\u0411\u0003\u0002\u0002", + "\u0002\u1fdb\u1fdc\u0005\u0414\u020b\u0002\u1fdc\u1fdd\u0005\u0416\u020c", + "\u0002\u1fdd\u1fde\u0005\u03a6\u01d4\u0002\u1fde\u0413\u0003\u0002\u0002", + "\u0002\u1fdf\u1fe9\u0007@\u0002\u0002\u1fe0\u1fe1\u0007\u0106\u0002", + "\u0002\u1fe1\u1fe3\u0007\u00ee\u0002\u0002\u1fe2\u1fe0\u0003\u0002\u0002", + "\u0002\u1fe2\u1fe3\u0003\u0002\u0002\u0002\u1fe3\u1fe4\u0003\u0002\u0002", + "\u0002\u1fe4\u1fea\u0007\u016a\u0002\u0002\u1fe5\u1fe7\u0007\u00ee\u0002", + "\u0002\u1fe6\u1fe5\u0003\u0002\u0002\u0002\u1fe6\u1fe7\u0003\u0002\u0002", + "\u0002\u1fe7\u1fe8\u0003\u0002\u0002\u0002\u1fe8\u1fea\u0007\u0147\u0002", + "\u0002\u1fe9\u1fe2\u0003\u0002\u0002\u0002\u1fe9\u1fe6\u0003\u0002\u0002", + "\u0002\u1fea\u0415\u0003\u0002\u0002\u0002\u1feb\u1fec\u0007\u010c\u0002", + "\u0002\u1fec\u1fef\u0005\u052c\u0297\u0002\u1fed\u1fef\u0003\u0002\u0002", + "\u0002\u1fee\u1feb\u0003\u0002\u0002\u0002\u1fee\u1fed\u0003\u0002\u0002", + "\u0002\u1fef\u0417\u0003\u0002\u0002\u0002\u1ff0\u1ff1\u0007\u019f\u0002", + "\u0002\u1ff1\u1ff2\u0007\u0004\u0002\u0002\u1ff2\u1ff3\u0005\u04f6\u027c", + "\u0002\u1ff3\u1ffb\u0007\u0005\u0002\u0002\u1ff4\u1ff5\u0007\b\u0002", + "\u0002\u1ff5\u1ff6\u0007\u0004\u0002\u0002\u1ff6\u1ff7\u0005\u04f6\u027c", + "\u0002\u1ff7\u1ff8\u0007\u0005\u0002\u0002\u1ff8\u1ffa\u0003\u0002\u0002", + "\u0002\u1ff9\u1ff4\u0003\u0002\u0002\u0002\u1ffa\u1ffd\u0003\u0002\u0002", + "\u0002\u1ffb\u1ff9\u0003\u0002\u0002\u0002\u1ffb\u1ffc\u0003\u0002\u0002", + "\u0002\u1ffc\u0419\u0003\u0002\u0002\u0002\u1ffd\u1ffb\u0003\u0002\u0002", + "\u0002\u1ffe\u1fff\u0007B\u0002\u0002\u1fff\u2002\u0005\u041c\u020f", + "\u0002\u2000\u2002\u0003\u0002\u0002\u0002\u2001\u1ffe\u0003\u0002\u0002", + "\u0002\u2001\u2000\u0003\u0002\u0002\u0002\u2002\u041b\u0003\u0002\u0002", + "\u0002\u2003\u2008\u0005\u041e\u0210\u0002\u2004\u2005\u0007\b\u0002", + "\u0002\u2005\u2007\u0005\u041e\u0210\u0002\u2006\u2004\u0003\u0002\u0002", + "\u0002\u2007\u200a\u0003\u0002\u0002\u0002\u2008\u2006\u0003\u0002\u0002", + "\u0002\u2008\u2009\u0003\u0002\u0002\u0002\u2009\u041d\u0003\u0002\u0002", + "\u0002\u200a\u2008\u0003\u0002\u0002\u0002\u200b\u200c\u0005\u042a\u0216", + "\u0002\u200c\u200e\u0005\u0422\u0212\u0002\u200d\u200f\u0005\u0430\u0219", + "\u0002\u200e\u200d\u0003\u0002\u0002\u0002\u200e\u200f\u0003\u0002\u0002", + "\u0002\u200f\u203d\u0003\u0002\u0002\u0002\u2010\u2011\u0005\u0434\u021b", + "\u0002\u2011\u2012\u0005\u0424\u0213\u0002\u2012\u203d\u0003\u0002\u0002", + "\u0002\u2013\u2014\u0005\u0448\u0225\u0002\u2014\u2015\u0005\u0422\u0212", + "\u0002\u2015\u203d\u0003\u0002\u0002\u0002\u2016\u2017\u0005\u03bc\u01df", + "\u0002\u2017\u2018\u0005\u0422\u0212\u0002\u2018\u203d\u0003\u0002\u0002", + "\u0002\u2019\u2023\u0007J\u0002\u0002\u201a\u201b\u0005\u0448\u0225", + "\u0002\u201b\u201c\u0005\u0422\u0212\u0002\u201c\u2024\u0003\u0002\u0002", + "\u0002\u201d\u201e\u0005\u0434\u021b\u0002\u201e\u201f\u0005\u0424\u0213", + "\u0002\u201f\u2024\u0003\u0002\u0002\u0002\u2020\u2021\u0005\u03bc\u01df", + "\u0002\u2021\u2022\u0005\u0422\u0212\u0002\u2022\u2024\u0003\u0002\u0002", + "\u0002\u2023\u201a\u0003\u0002\u0002\u0002\u2023\u201d\u0003\u0002\u0002", + "\u0002\u2023\u2020\u0003\u0002\u0002\u0002\u2024\u203d\u0003\u0002\u0002", + "\u0002\u2025\u2026\u0007\u0004\u0002\u0002\u2026\u2037\u0005\u041e\u0210", + "\u0002\u2027\u2028\u0007p\u0002\u0002\u2028\u2029\u0007x\u0002\u0002", + "\u2029\u2038\u0005\u041e\u0210\u0002\u202a\u202c\u0007{\u0002\u0002", + "\u202b\u202d\u0005\u0426\u0214\u0002\u202c\u202b\u0003\u0002\u0002\u0002", + "\u202c\u202d\u0003\u0002\u0002\u0002\u202d\u202e\u0003\u0002\u0002\u0002", + "\u202e\u202f\u0007x\u0002\u0002\u202f\u2038\u0005\u041e\u0210\u0002", + "\u2030\u2032\u0005\u0426\u0214\u0002\u2031\u2030\u0003\u0002\u0002\u0002", + "\u2031\u2032\u0003\u0002\u0002\u0002\u2032\u2033\u0003\u0002\u0002\u0002", + "\u2033\u2034\u0007x\u0002\u0002\u2034\u2035\u0005\u041e\u0210\u0002", + "\u2035\u2036\u0005\u0428\u0215\u0002\u2036\u2038\u0003\u0002\u0002\u0002", + "\u2037\u2027\u0003\u0002\u0002\u0002\u2037\u202a\u0003\u0002\u0002\u0002", + "\u2037\u2031\u0003\u0002\u0002\u0002\u2037\u2038\u0003\u0002\u0002\u0002", + "\u2038\u2039\u0003\u0002\u0002\u0002\u2039\u203a\u0007\u0005\u0002\u0002", + "\u203a\u203b\u0005\u0422\u0212\u0002\u203b\u203d\u0003\u0002\u0002\u0002", + "\u203c\u200b\u0003\u0002\u0002\u0002\u203c\u2010\u0003\u0002\u0002\u0002", + "\u203c\u2013\u0003\u0002\u0002\u0002\u203c\u2016\u0003\u0002\u0002\u0002", + "\u203c\u2019\u0003\u0002\u0002\u0002\u203c\u2025\u0003\u0002\u0002\u0002", + "\u203d\u2050\u0003\u0002\u0002\u0002\u203e\u203f\u0007p\u0002\u0002", + "\u203f\u2040\u0007x\u0002\u0002\u2040\u204f\u0005\u041e\u0210\u0002", + "\u2041\u2043\u0007{\u0002\u0002\u2042\u2044\u0005\u0426\u0214\u0002", + "\u2043\u2042\u0003\u0002\u0002\u0002\u2043\u2044\u0003\u0002\u0002\u0002", + "\u2044\u2045\u0003\u0002\u0002\u0002\u2045\u2046\u0007x\u0002\u0002", + "\u2046\u204f\u0005\u041e\u0210\u0002\u2047\u2049\u0005\u0426\u0214\u0002", + "\u2048\u2047\u0003\u0002\u0002\u0002\u2048\u2049\u0003\u0002\u0002\u0002", + "\u2049\u204a\u0003\u0002\u0002\u0002\u204a\u204b\u0007x\u0002\u0002", + "\u204b\u204c\u0005\u041e\u0210\u0002\u204c\u204d\u0005\u0428\u0215\u0002", + "\u204d\u204f\u0003\u0002\u0002\u0002\u204e\u203e\u0003\u0002\u0002\u0002", + "\u204e\u2041\u0003\u0002\u0002\u0002\u204e\u2048\u0003\u0002\u0002\u0002", + "\u204f\u2052\u0003\u0002\u0002\u0002\u2050\u204e\u0003\u0002\u0002\u0002", + "\u2050\u2051\u0003\u0002\u0002\u0002\u2051\u041f\u0003\u0002\u0002\u0002", + "\u2052\u2050\u0003\u0002\u0002\u0002\u2053\u2055\u0007&\u0002\u0002", + "\u2054\u2053\u0003\u0002\u0002\u0002\u2054\u2055\u0003\u0002\u0002\u0002", + "\u2055\u2056\u0003\u0002\u0002\u0002\u2056\u205b\u0005\u0552\u02aa\u0002", + "\u2057\u2058\u0007\u0004\u0002\u0002\u2058\u2059\u0005\u0530\u0299\u0002", + "\u2059\u205a\u0007\u0005\u0002\u0002\u205a\u205c\u0003\u0002\u0002\u0002", + "\u205b\u2057\u0003\u0002\u0002\u0002\u205b\u205c\u0003\u0002\u0002\u0002", + "\u205c\u0421\u0003\u0002\u0002\u0002\u205d\u2060\u0005\u0420\u0211\u0002", + "\u205e\u2060\u0003\u0002\u0002\u0002\u205f\u205d\u0003\u0002\u0002\u0002", + "\u205f\u205e\u0003\u0002\u0002\u0002\u2060\u0423\u0003\u0002\u0002\u0002", + "\u2061\u206f\u0005\u0420\u0211\u0002\u2062\u2064\u0007&\u0002\u0002", + "\u2063\u2065\u0005\u0552\u02aa\u0002\u2064\u2063\u0003\u0002\u0002\u0002", + "\u2064\u2065\u0003\u0002\u0002\u0002\u2065\u2068\u0003\u0002\u0002\u0002", + "\u2066\u2068\u0005\u0552\u02aa\u0002\u2067\u2062\u0003\u0002\u0002\u0002", + "\u2067\u2066\u0003\u0002\u0002\u0002\u2068\u2069\u0003\u0002\u0002\u0002", + "\u2069\u206a\u0007\u0004\u0002\u0002\u206a\u206b\u0005\u0444\u0223\u0002", + "\u206b\u206c\u0007\u0005\u0002\u0002\u206c\u206f\u0003\u0002\u0002\u0002", + "\u206d\u206f\u0003\u0002\u0002\u0002\u206e\u2061\u0003\u0002\u0002\u0002", + "\u206e\u2067\u0003\u0002\u0002\u0002\u206e\u206d\u0003\u0002\u0002\u0002", + "\u206f\u0425\u0003\u0002\u0002\u0002\u2070\u2072\t(\u0002\u0002\u2071", + "\u2073\u0007}\u0002\u0002\u2072\u2071\u0003\u0002\u0002\u0002\u2072", + "\u2073\u0003\u0002\u0002\u0002\u2073\u0427\u0003\u0002\u0002\u0002\u2074", + "\u2075\u0007f\u0002\u0002\u2075\u2076\u0007\u0004\u0002\u0002\u2076", + "\u2077\u0005\u0530\u0299\u0002\u2077\u2078\u0007\u0005\u0002\u0002\u2078", + "\u207c\u0003\u0002\u0002\u0002\u2079\u207a\u0007R\u0002\u0002\u207a", + "\u207c\u0005\u0482\u0242\u0002\u207b\u2074\u0003\u0002\u0002\u0002\u207b", + "\u2079\u0003\u0002\u0002\u0002\u207c\u0429\u0003\u0002\u0002\u0002\u207d", + "\u207f\u0005\u052e\u0298\u0002\u207e\u2080\u0007\u000b\u0002\u0002\u207f", + "\u207e\u0003\u0002\u0002\u0002\u207f\u2080\u0003\u0002\u0002\u0002\u2080", + "\u208a\u0003\u0002\u0002\u0002\u2081\u2087\u0007S\u0002\u0002\u2082", + "\u2088\u0005\u052e\u0298\u0002\u2083\u2084\u0007\u0004\u0002\u0002\u2084", + "\u2085\u0005\u052e\u0298\u0002\u2085\u2086\u0007\u0005\u0002\u0002\u2086", + "\u2088\u0003\u0002\u0002\u0002\u2087\u2082\u0003\u0002\u0002\u0002\u2087", + "\u2083\u0003\u0002\u0002\u0002\u2088\u208a\u0003\u0002\u0002\u0002\u2089", + "\u207d\u0003\u0002\u0002\u0002\u2089\u2081\u0003\u0002\u0002\u0002\u208a", + "\u042b\u0003\u0002\u0002\u0002\u208b\u2090\u0005\u042a\u0216\u0002\u208c", + "\u208d\u0007\b\u0002\u0002\u208d\u208f\u0005\u042a\u0216\u0002\u208e", + "\u208c\u0003\u0002\u0002\u0002\u208f\u2092\u0003\u0002\u0002\u0002\u2090", + "\u208e\u0003\u0002\u0002\u0002\u2090\u2091\u0003\u0002\u0002\u0002\u2091", + "\u042d\u0003\u0002\u0002\u0002\u2092\u2090\u0003\u0002\u0002\u0002\u2093", + "\u2098\u0005\u042a\u0216\u0002\u2094\u2096\u0007&\u0002\u0002\u2095", + "\u2094\u0003\u0002\u0002\u0002\u2095\u2096\u0003\u0002\u0002\u0002\u2096", + "\u2097\u0003\u0002\u0002\u0002\u2097\u2099\u0005\u0552\u02aa\u0002\u2098", + "\u2095\u0003\u0002\u0002\u0002\u2098\u2099\u0003\u0002\u0002\u0002\u2099", + "\u042f\u0003\u0002\u0002\u0002\u209a\u209b\u0007\u01d1\u0002\u0002\u209b", + "\u209c\u0005\u0538\u029d\u0002\u209c\u209d\u0007\u0004\u0002\u0002\u209d", + "\u209e\u0005\u04f6\u027c\u0002\u209e\u209f\u0007\u0005\u0002\u0002\u209f", + "\u20a0\u0005\u0432\u021a\u0002\u20a0\u0431\u0003\u0002\u0002\u0002\u20a1", + "\u20a2\u0007\u012f\u0002\u0002\u20a2\u20a3\u0007\u0004\u0002\u0002\u20a3", + "\u20a4\u0005\u0482\u0242\u0002\u20a4\u20a5\u0007\u0005\u0002\u0002\u20a5", + "\u20a8\u0003\u0002\u0002\u0002\u20a6\u20a8\u0003\u0002\u0002\u0002\u20a7", + "\u20a1\u0003\u0002\u0002\u0002\u20a7\u20a6\u0003\u0002\u0002\u0002\u20a8", + "\u0433\u0003\u0002\u0002\u0002\u20a9\u20aa\u0005\u04b4\u025b\u0002\u20aa", + "\u20ab\u0005\u043c\u021f\u0002\u20ab\u20b4\u0003\u0002\u0002\u0002\u20ac", + "\u20ad\u0007\u0139\u0002\u0002\u20ad\u20ae\u0007B\u0002\u0002\u20ae", + "\u20af\u0007\u0004\u0002\u0002\u20af\u20b0\u0005\u0438\u021d\u0002\u20b0", + "\u20b1\u0007\u0005\u0002\u0002\u20b1\u20b2\u0005\u043c\u021f\u0002\u20b2", + "\u20b4\u0003\u0002\u0002\u0002\u20b3\u20a9\u0003\u0002\u0002\u0002\u20b3", + "\u20ac\u0003\u0002\u0002\u0002\u20b4\u0435\u0003\u0002\u0002\u0002\u20b5", + "\u20b6\u0005\u04b4\u025b\u0002\u20b6\u20b7\u0005\u043a\u021e\u0002\u20b7", + "\u0437\u0003\u0002\u0002\u0002\u20b8\u20bd\u0005\u0436\u021c\u0002\u20b9", + "\u20ba\u0007\b\u0002\u0002\u20ba\u20bc\u0005\u0436\u021c\u0002\u20bb", + "\u20b9\u0003\u0002\u0002\u0002\u20bc\u20bf\u0003\u0002\u0002\u0002\u20bd", + "\u20bb\u0003\u0002\u0002\u0002\u20bd\u20be\u0003\u0002\u0002\u0002\u20be", + "\u0439\u0003\u0002\u0002\u0002\u20bf\u20bd\u0003\u0002\u0002\u0002\u20c0", + "\u20c1\u0007&\u0002\u0002\u20c1\u20c2\u0007\u0004\u0002\u0002\u20c2", + "\u20c3\u0005\u0444\u0223\u0002\u20c3\u20c4\u0007\u0005\u0002\u0002\u20c4", + "\u20c7\u0003\u0002\u0002\u0002\u20c5\u20c7\u0003\u0002\u0002\u0002\u20c6", + "\u20c0\u0003\u0002\u0002\u0002\u20c6\u20c5\u0003\u0002\u0002\u0002\u20c7", + "\u043b\u0003\u0002\u0002\u0002\u20c8\u20c9\u0007k\u0002\u0002\u20c9", + "\u20cc\u0007\u01d2\u0002\u0002\u20ca\u20cc\u0003\u0002\u0002\u0002\u20cb", + "\u20c8\u0003\u0002\u0002\u0002\u20cb\u20ca\u0003\u0002\u0002\u0002\u20cc", + "\u043d\u0003\u0002\u0002\u0002\u20cd\u20ce\u0007i\u0002\u0002\u20ce", + "\u20d1\u0005\u0482\u0242\u0002\u20cf\u20d1\u0003\u0002\u0002\u0002\u20d0", + "\u20cd\u0003\u0002\u0002\u0002\u20d0\u20cf\u0003\u0002\u0002\u0002\u20d1", + "\u043f\u0003\u0002\u0002\u0002\u20d2\u20d7\u0007i\u0002\u0002\u20d3", + "\u20d4\u0007\u01ab\u0002\u0002\u20d4\u20d5\u0007\u010c\u0002\u0002\u20d5", + "\u20d8\u0005\u03b4\u01db\u0002\u20d6\u20d8\u0005\u0482\u0242\u0002\u20d7", + "\u20d3\u0003\u0002\u0002\u0002\u20d7\u20d6\u0003\u0002\u0002\u0002\u20d8", + "\u20db\u0003\u0002\u0002\u0002\u20d9\u20db\u0003\u0002\u0002\u0002\u20da", + "\u20d2\u0003\u0002\u0002\u0002\u20da\u20d9\u0003\u0002\u0002\u0002\u20db", + "\u0441\u0003\u0002\u0002\u0002\u20dc\u20df\u0005\u0444\u0223\u0002\u20dd", + "\u20df\u0003\u0002\u0002\u0002\u20de\u20dc\u0003\u0002\u0002\u0002\u20de", + "\u20dd\u0003\u0002\u0002\u0002\u20df\u0443\u0003\u0002\u0002\u0002\u20e0", + "\u20e5\u0005\u0446\u0224\u0002\u20e1\u20e2\u0007\b\u0002\u0002\u20e2", + "\u20e4\u0005\u0446\u0224\u0002\u20e3\u20e1\u0003\u0002\u0002\u0002\u20e4", + "\u20e7\u0003\u0002\u0002\u0002\u20e5\u20e3\u0003\u0002\u0002\u0002\u20e5", + "\u20e6\u0003\u0002\u0002\u0002\u20e6\u0445\u0003\u0002\u0002\u0002\u20e7", + "\u20e5\u0003\u0002\u0002\u0002\u20e8\u20e9\u0005\u0552\u02aa\u0002\u20e9", + "\u20ea\u0005\u0456\u022c\u0002\u20ea\u20eb\u0005p9\u0002\u20eb\u0447", + "\u0003\u0002\u0002\u0002\u20ec\u20ed\u0007\u01d3\u0002\u0002\u20ed\u20fd", + "\u0007\u0004\u0002\u0002\u20ee\u20ef\u0005\u04ac\u0257\u0002\u20ef\u20f0", + "\u0005\u04c6\u0264\u0002\u20f0\u20f1\u0007\u01d4\u0002\u0002\u20f1\u20f2", + "\u0005\u044a\u0226\u0002\u20f2\u20fe\u0003\u0002\u0002\u0002\u20f3\u20f4", + "\u0007\u01d5\u0002\u0002\u20f4\u20f5\u0007\u0004\u0002\u0002\u20f5\u20f6", + "\u0005\u0452\u022a\u0002\u20f6\u20f7\u0007\u0005\u0002\u0002\u20f7\u20f8", + "\u0007\b\u0002\u0002\u20f8\u20f9\u0005\u04ac\u0257\u0002\u20f9\u20fa", + "\u0005\u04c6\u0264\u0002\u20fa\u20fb\u0007\u01d4\u0002\u0002\u20fb\u20fc", + "\u0005\u044a\u0226\u0002\u20fc\u20fe\u0003\u0002\u0002\u0002\u20fd\u20ee", + "\u0003\u0002\u0002\u0002\u20fd\u20f3\u0003\u0002\u0002\u0002\u20fe\u20ff", + "\u0003\u0002\u0002\u0002\u20ff\u2100\u0007\u0005\u0002\u0002\u2100\u0449", + "\u0003\u0002\u0002\u0002\u2101\u2106\u0005\u044c\u0227\u0002\u2102\u2103", + "\u0007\b\u0002\u0002\u2103\u2105\u0005\u044c\u0227\u0002\u2104\u2102", + "\u0003\u0002\u0002\u0002\u2105\u2108\u0003\u0002\u0002\u0002\u2106\u2104", + "\u0003\u0002\u0002\u0002\u2106\u2107\u0003\u0002\u0002\u0002\u2107\u044b", + "\u0003\u0002\u0002\u0002\u2108\u2106\u0003\u0002\u0002\u0002\u2109\u2110", + "\u0005\u0552\u02aa\u0002\u210a\u210c\u0005\u0456\u022c\u0002\u210b\u210d", + "\u0005\u044e\u0228\u0002\u210c\u210b\u0003\u0002\u0002\u0002\u210c\u210d", + "\u0003\u0002\u0002\u0002\u210d\u2111\u0003\u0002\u0002\u0002\u210e\u210f", + "\u0007@\u0002\u0002\u210f\u2111\u0007\u01d2\u0002\u0002\u2110\u210a", + "\u0003\u0002\u0002\u0002\u2110\u210e\u0003\u0002\u0002\u0002\u2111\u044d", + "\u0003\u0002\u0002\u0002\u2112\u2114\u0005\u0450\u0229\u0002\u2113\u2112", + "\u0003\u0002\u0002\u0002\u2114\u2115\u0003\u0002\u0002\u0002\u2115\u2113", + "\u0003\u0002\u0002\u0002\u2115\u2116\u0003\u0002\u0002\u0002\u2116\u044f", + "\u0003\u0002\u0002\u0002\u2117\u2118\u00077\u0002\u0002\u2118\u2120", + "\u0005\u0482\u0242\u0002\u2119\u211a\u0005\u055a\u02ae\u0002\u211a\u211b", + "\u0005\u0482\u0242\u0002\u211b\u2120\u0003\u0002\u0002\u0002\u211c\u211d", + "\u0007O\u0002\u0002\u211d\u2120\u0007P\u0002\u0002\u211e\u2120\u0007", + "P\u0002\u0002\u211f\u2117\u0003\u0002\u0002\u0002\u211f\u2119\u0003", + "\u0002\u0002\u0002\u211f\u211c\u0003\u0002\u0002\u0002\u211f\u211e\u0003", + "\u0002\u0002\u0002\u2120\u0451\u0003\u0002\u0002\u0002\u2121\u2126\u0005", + "\u0454\u022b\u0002\u2122\u2123\u0007\b\u0002\u0002\u2123\u2125\u0005", + "\u0454\u022b\u0002\u2124\u2122\u0003\u0002\u0002\u0002\u2125\u2128\u0003", + "\u0002\u0002\u0002\u2126\u2124\u0003\u0002\u0002\u0002\u2126\u2127\u0003", + "\u0002\u0002\u0002\u2127\u0453\u0003\u0002\u0002\u0002\u2128\u2126\u0003", + "\u0002\u0002\u0002\u2129\u212a\u0005\u04aa\u0256\u0002\u212a\u212b\u0007", + "&\u0002\u0002\u212b\u212c\u0005\u0558\u02ad\u0002\u212c\u2130\u0003", + "\u0002\u0002\u0002\u212d\u212e\u00077\u0002\u0002\u212e\u2130\u0005", + "\u04aa\u0256\u0002\u212f\u2129\u0003\u0002\u0002\u0002\u212f\u212d\u0003", + "\u0002\u0002\u0002\u2130\u0455\u0003\u0002\u0002\u0002\u2131\u2133\u0007", + "\u0198\u0002\u0002\u2132\u2131\u0003\u0002\u0002\u0002\u2132\u2133\u0003", + "\u0002\u0002\u0002\u2133\u2134\u0003\u0002\u0002\u0002\u2134\u213d\u0005", + "\u045a\u022e\u0002\u2135\u213e\u0005\u0458\u022d\u0002\u2136\u213b\u0007", + "%\u0002\u0002\u2137\u2138\u0007\u0006\u0002\u0002\u2138\u2139\u0005", + "\u0542\u02a2\u0002\u2139\u213a\u0007\u0007\u0002\u0002\u213a\u213c\u0003", + "\u0002\u0002\u0002\u213b\u2137\u0003\u0002\u0002\u0002\u213b\u213c\u0003", + "\u0002\u0002\u0002\u213c\u213e\u0003\u0002\u0002\u0002\u213d\u2135\u0003", + "\u0002\u0002\u0002\u213d\u2136\u0003\u0002\u0002\u0002\u213e\u2144\u0003", + "\u0002\u0002\u0002\u213f\u2140\u0005\u052e\u0298\u0002\u2140\u2141\u0007", + "\u001d\u0002\u0002\u2141\u2142\t)\u0002\u0002\u2142\u2144\u0003\u0002", + "\u0002\u0002\u2143\u2132\u0003\u0002\u0002\u0002\u2143\u213f\u0003\u0002", + "\u0002\u0002\u2144\u0457\u0003\u0002\u0002\u0002\u2145\u2147\u0007\u0006", + "\u0002\u0002\u2146\u2148\u0005\u0542\u02a2\u0002\u2147\u2146\u0003\u0002", + "\u0002\u0002\u2147\u2148\u0003\u0002\u0002\u0002\u2148\u2149\u0003\u0002", + "\u0002\u0002\u2149\u214b\u0007\u0007\u0002\u0002\u214a\u2145\u0003\u0002", + "\u0002\u0002\u214b\u214e\u0003\u0002\u0002\u0002\u214c\u214a\u0003\u0002", + "\u0002\u0002\u214c\u214d\u0003\u0002\u0002\u0002\u214d\u0459\u0003\u0002", + "\u0002\u0002\u214e\u214c\u0003\u0002\u0002\u0002\u214f\u215d\u0005\u045e", + "\u0230\u0002\u2150\u215d\u0005\u0462\u0232\u0002\u2151\u215d\u0005\u0466", + "\u0234\u0002\u2152\u215d\u0005\u046e\u0238\u0002\u2153\u215d\u0005\u0476", + "\u023c\u0002\u2154\u215a\u0005\u0478\u023d\u0002\u2155\u215b\u0005\u047c", + "\u023f\u0002\u2156\u2157\u0007\u0004\u0002\u0002\u2157\u2158\u0005\u0542", + "\u02a2\u0002\u2158\u2159\u0007\u0005\u0002\u0002\u2159\u215b\u0003\u0002", + "\u0002\u0002\u215a\u2155\u0003\u0002\u0002\u0002\u215a\u2156\u0003\u0002", + "\u0002\u0002\u215b\u215d\u0003\u0002\u0002\u0002\u215c\u214f\u0003\u0002", + "\u0002\u0002\u215c\u2150\u0003\u0002\u0002\u0002\u215c\u2151\u0003\u0002", + "\u0002\u0002\u215c\u2152\u0003\u0002\u0002\u0002\u215c\u2153\u0003\u0002", + "\u0002\u0002\u215c\u2154\u0003\u0002\u0002\u0002\u215d\u045b\u0003\u0002", + "\u0002\u0002\u215e\u2163\u0005\u0462\u0232\u0002\u215f\u2163\u0005\u0468", + "\u0235\u0002\u2160\u2163\u0005\u0470\u0239\u0002\u2161\u2163\u0005\u0476", + "\u023c\u0002\u2162\u215e\u0003\u0002\u0002\u0002\u2162\u215f\u0003\u0002", + "\u0002\u0002\u2162\u2160\u0003\u0002\u0002\u0002\u2162\u2161\u0003\u0002", + "\u0002\u0002\u2163\u045d\u0003\u0002\u0002\u0002\u2164\u2166\u0005\u0554", + "\u02ab\u0002\u2165\u2167\u0005\u0210\u0109\u0002\u2166\u2165\u0003\u0002", + "\u0002\u0002\u2166\u2167\u0003\u0002\u0002\u0002\u2167\u2168\u0003\u0002", + "\u0002\u0002\u2168\u2169\u0005\u0460\u0231\u0002\u2169\u045f\u0003\u0002", + "\u0002\u0002\u216a\u216b\u0007\u0004\u0002\u0002\u216b\u216c\u0005\u04f6", + "\u027c\u0002\u216c\u216d\u0007\u0005\u0002\u0002\u216d\u2170\u0003\u0002", + "\u0002\u0002\u216e\u2170\u0003\u0002\u0002\u0002\u216f\u216a\u0003\u0002", + "\u0002\u0002\u216f\u216e\u0003\u0002\u0002\u0002\u2170\u0461\u0003\u0002", + "\u0002\u0002\u2171\u2182\u0007\u018a\u0002\u0002\u2172\u2182\u0007\u018b", + "\u0002\u0002\u2173\u2182\u0007\u0199\u0002\u0002\u2174\u2182\u0007\u017d", + "\u0002\u0002\u2175\u2182\u0007\u0196\u0002\u0002\u2176\u2177\u0007\u0187", + "\u0002\u0002\u2177\u2182\u0005\u0464\u0233\u0002\u2178\u2179\u0007\u00c0", + "\u0002\u0002\u2179\u2182\u0007\u0195\u0002\u0002\u217a\u217b\u0007\u0184", + "\u0002\u0002\u217b\u2182\u0005\u0460\u0231\u0002\u217c\u217d\u0007\u0183", + "\u0002\u0002\u217d\u2182\u0005\u0460\u0231\u0002\u217e\u217f\u0007\u0192", + "\u0002\u0002\u217f\u2182\u0005\u0460\u0231\u0002\u2180\u2182\u0007\u017f", + "\u0002\u0002\u2181\u2171\u0003\u0002\u0002\u0002\u2181\u2172\u0003\u0002", + "\u0002\u0002\u2181\u2173\u0003\u0002\u0002\u0002\u2181\u2174\u0003\u0002", + "\u0002\u0002\u2181\u2175\u0003\u0002\u0002\u0002\u2181\u2176\u0003\u0002", + "\u0002\u0002\u2181\u2178\u0003\u0002\u0002\u0002\u2181\u217a\u0003\u0002", + "\u0002\u0002\u2181\u217c\u0003\u0002\u0002\u0002\u2181\u217e\u0003\u0002", + "\u0002\u0002\u2181\u2180\u0003\u0002\u0002\u0002\u2182\u0463\u0003\u0002", + "\u0002\u0002\u2183\u2184\u0007\u0004\u0002\u0002\u2184\u2185\u0005\u0542", + "\u02a2\u0002\u2185\u2186\u0007\u0005\u0002\u0002\u2186\u2189\u0003\u0002", + "\u0002\u0002\u2187\u2189\u0003\u0002\u0002\u0002\u2188\u2183\u0003\u0002", + "\u0002\u0002\u2188\u2187\u0003\u0002\u0002\u0002\u2189\u0465\u0003\u0002", + "\u0002\u0002\u218a\u218d\u0005\u046a\u0236\u0002\u218b\u218d\u0005\u046c", + "\u0237\u0002\u218c\u218a\u0003\u0002\u0002\u0002\u218c\u218b\u0003\u0002", + "\u0002\u0002\u218d\u0467\u0003\u0002\u0002\u0002\u218e\u2191\u0005\u046a", + "\u0236\u0002\u218f\u2191\u0005\u046c\u0237\u0002\u2190\u218e\u0003\u0002", + "\u0002\u0002\u2190\u218f\u0003\u0002\u0002\u0002\u2191\u0469\u0003\u0002", + "\u0002\u0002\u2192\u2193\u0007\u017e\u0002\u0002\u2193\u2194\u0005\u0474", + "\u023b\u0002\u2194\u2195\u0007\u0004\u0002\u0002\u2195\u2196\u0005\u04f6", + "\u027c\u0002\u2196\u2197\u0007\u0005\u0002\u0002\u2197\u046b\u0003\u0002", + "\u0002\u0002\u2198\u2199\u0007\u017e\u0002\u0002\u2199\u219a\u0005\u0474", + "\u023b\u0002\u219a\u046d\u0003\u0002\u0002\u0002\u219b\u21a0\u0005\u0472", + "\u023a\u0002\u219c\u219d\u0007\u0004\u0002\u0002\u219d\u219e\u0005\u0542", + "\u02a2\u0002\u219e\u219f\u0007\u0005\u0002\u0002\u219f\u21a1\u0003\u0002", + "\u0002\u0002\u21a0\u219c\u0003\u0002\u0002\u0002\u21a0\u21a1\u0003\u0002", + "\u0002\u0002\u21a1\u046f\u0003\u0002\u0002\u0002\u21a2\u21a7\u0005\u0472", + "\u023a\u0002\u21a3\u21a4\u0007\u0004\u0002\u0002\u21a4\u21a5\u0005\u0542", + "\u02a2\u0002\u21a5\u21a6\u0007\u0005\u0002\u0002\u21a6\u21a8\u0003\u0002", + "\u0002\u0002\u21a7\u21a3\u0003\u0002\u0002\u0002\u21a7\u21a8\u0003\u0002", + "\u0002\u0002\u21a8\u0471\u0003\u0002\u0002\u0002\u21a9\u21aa\t*\u0002", + "\u0002\u21aa\u21b0\u0005\u0474\u023b\u0002\u21ab\u21b0\u0007\u01a0\u0002", + "\u0002\u21ac\u21ad\u0007\u018e\u0002\u0002\u21ad\u21ae\t+\u0002\u0002", + "\u21ae\u21b0\u0005\u0474\u023b\u0002\u21af\u21a9\u0003\u0002\u0002\u0002", + "\u21af\u21ab\u0003\u0002\u0002\u0002\u21af\u21ac\u0003\u0002\u0002\u0002", + "\u21b0\u0473\u0003\u0002\u0002\u0002\u21b1\u21b4\u0007\u016f\u0002\u0002", + "\u21b2\u21b4\u0003\u0002\u0002\u0002\u21b3\u21b1\u0003\u0002\u0002\u0002", + "\u21b3\u21b2\u0003\u0002\u0002\u0002\u21b4\u0475\u0003\u0002\u0002\u0002", + "\u21b5\u21ba\t,\u0002\u0002\u21b6\u21b7\u0007\u0004\u0002\u0002\u21b7", + "\u21b8\u0005\u0542\u02a2\u0002\u21b8\u21b9\u0007\u0005\u0002\u0002\u21b9", + "\u21bb\u0003\u0002\u0002\u0002\u21ba\u21b6\u0003\u0002\u0002\u0002\u21ba", + "\u21bb\u0003\u0002\u0002\u0002\u21bb\u21bc\u0003\u0002\u0002\u0002\u21bc", + "\u21bd\u0005\u047a\u023e\u0002\u21bd\u0477\u0003\u0002\u0002\u0002\u21be", + "\u21bf\u0007\u018c\u0002\u0002\u21bf\u0479\u0003\u0002\u0002\u0002\u21c0", + "\u21c1\u0007k\u0002\u0002\u21c1\u21c2\u0007\u019b\u0002\u0002\u21c2", + "\u21c8\u0007\u017b\u0002\u0002\u21c3\u21c4\u0007\u0174\u0002\u0002\u21c4", + "\u21c5\u0007\u019b\u0002\u0002\u21c5\u21c8\u0007\u017b\u0002\u0002\u21c6", + "\u21c8\u0003\u0002\u0002\u0002\u21c7\u21c0\u0003\u0002\u0002\u0002\u21c7", + "\u21c3\u0003\u0002\u0002\u0002\u21c7\u21c6\u0003\u0002\u0002\u0002\u21c8", + "\u047b\u0003\u0002\u0002\u0002\u21c9\u21e4\u0007\u0179\u0002\u0002\u21ca", + "\u21e4\u0007\u0101\u0002\u0002\u21cb\u21e4\u0007\u00b2\u0002\u0002\u21cc", + "\u21e4\u0007\u00dc\u0002\u0002\u21cd\u21e4\u0007\u00fe\u0002\u0002\u21ce", + "\u21e4\u0005\u047e\u0240\u0002\u21cf\u21d0\u0007\u0179\u0002\u0002\u21d0", + "\u21d1\u0007`\u0002\u0002\u21d1\u21e4\u0007\u0101\u0002\u0002\u21d2", + "\u21d3\u0007\u00b2\u0002\u0002\u21d3\u21d7\u0007`\u0002\u0002\u21d4", + "\u21d8\u0007\u00dc\u0002\u0002\u21d5\u21d8\u0007\u00fe\u0002\u0002\u21d6", + "\u21d8\u0005\u047e\u0240\u0002\u21d7\u21d4\u0003\u0002\u0002\u0002\u21d7", + "\u21d5\u0003\u0002\u0002\u0002\u21d7\u21d6\u0003\u0002\u0002\u0002\u21d8", + "\u21e4\u0003\u0002\u0002\u0002\u21d9\u21da\u0007\u00dc\u0002\u0002\u21da", + "\u21dd\u0007`\u0002\u0002\u21db\u21de\u0007\u00fe\u0002\u0002\u21dc", + "\u21de\u0005\u047e\u0240\u0002\u21dd\u21db\u0003\u0002\u0002\u0002\u21dd", + "\u21dc\u0003\u0002\u0002\u0002\u21de\u21e4\u0003\u0002\u0002\u0002\u21df", + "\u21e0\u0007\u00fe\u0002\u0002\u21e0\u21e1\u0007`\u0002\u0002\u21e1", + "\u21e4\u0005\u047e\u0240\u0002\u21e2\u21e4\u0003\u0002\u0002\u0002\u21e3", + "\u21c9\u0003\u0002\u0002\u0002\u21e3\u21ca\u0003\u0002\u0002\u0002\u21e3", + "\u21cb\u0003\u0002\u0002\u0002\u21e3\u21cc\u0003\u0002\u0002\u0002\u21e3", + "\u21cd\u0003\u0002\u0002\u0002\u21e3\u21ce\u0003\u0002\u0002\u0002\u21e3", + "\u21cf\u0003\u0002\u0002\u0002\u21e3\u21d2\u0003\u0002\u0002\u0002\u21e3", + "\u21d9\u0003\u0002\u0002\u0002\u21e3\u21df\u0003\u0002\u0002\u0002\u21e3", + "\u21e2\u0003\u0002\u0002\u0002\u21e4\u047d\u0003\u0002\u0002\u0002\u21e5", + "\u21ea\u0007\u013f\u0002\u0002\u21e6\u21e7\u0007\u0004\u0002\u0002\u21e7", + "\u21e8\u0005\u0542\u02a2\u0002\u21e8\u21e9\u0007\u0005\u0002\u0002\u21e9", + "\u21eb\u0003\u0002\u0002\u0002\u21ea\u21e6\u0003\u0002\u0002\u0002\u21ea", + "\u21eb\u0003\u0002\u0002\u0002\u21eb\u047f\u0003\u0002\u0002\u0002\u21ec", + "\u21ed\u0007\u00c7\u0002\u0002\u21ed\u21f0\u0005\u0482\u0242\u0002\u21ee", + "\u21f0\u0003\u0002\u0002\u0002\u21ef\u21ec\u0003\u0002\u0002\u0002\u21ef", + "\u21ee\u0003\u0002\u0002\u0002\u21f0\u0481\u0003\u0002\u0002\u0002\u21f1", + "\u21f2\u0005\u0484\u0243\u0002\u21f2\u0483\u0003\u0002\u0002\u0002\u21f3", + "\u21f5\u0005\u0486\u0244\u0002\u21f4\u21f6\u0005\u04f0\u0279\u0002\u21f5", + "\u21f4\u0003\u0002\u0002\u0002\u21f5\u21f6\u0003\u0002\u0002\u0002\u21f6", + "\u0485\u0003\u0002\u0002\u0002\u21f7\u21fc\u0005\u0488\u0245\u0002\u21f8", + "\u21f9\t-\u0002\u0002\u21f9\u21fb\u0005\u0488\u0245\u0002\u21fa\u21f8", + "\u0003\u0002\u0002\u0002\u21fb\u21fe\u0003\u0002\u0002\u0002\u21fc\u21fa", + "\u0003\u0002\u0002\u0002\u21fc\u21fd\u0003\u0002\u0002\u0002\u21fd\u0487", + "\u0003\u0002\u0002\u0002\u21fe\u21fc\u0003\u0002\u0002\u0002\u21ff\u2204", + "\u0005\u048a\u0246\u0002\u2200\u2201\u0007T\u0002\u0002\u2201\u2203", + "\u0005\u048a\u0246\u0002\u2202\u2200\u0003\u0002\u0002\u0002\u2203\u2206", + "\u0003\u0002\u0002\u0002\u2204\u2202\u0003\u0002\u0002\u0002\u2204\u2205", + "\u0003\u0002\u0002\u0002\u2205\u0489\u0003\u0002\u0002\u0002\u2206\u2204", + "\u0003\u0002\u0002\u0002\u2207\u220c\u0005\u048c\u0247\u0002\u2208\u2209", + "\u0007#\u0002\u0002\u2209\u220b\u0005\u048c\u0247\u0002\u220a\u2208", + "\u0003\u0002\u0002\u0002\u220b\u220e\u0003\u0002\u0002\u0002\u220c\u220a", + "\u0003\u0002\u0002\u0002\u220c\u220d\u0003\u0002\u0002\u0002\u220d\u048b", + "\u0003\u0002\u0002\u0002\u220e\u220c\u0003\u0002\u0002\u0002\u220f\u2215", + "\u0005\u048e\u0248\u0002\u2210\u2212\u0007O\u0002\u0002\u2211\u2210", + "\u0003\u0002\u0002\u0002\u2211\u2212\u0003\u0002\u0002\u0002\u2212\u2213", + "\u0003\u0002\u0002\u0002\u2213\u2214\u0007F\u0002\u0002\u2214\u2216", + "\u0005\u0510\u0289\u0002\u2215\u2211\u0003\u0002\u0002\u0002\u2215\u2216", + "\u0003\u0002\u0002\u0002\u2216\u048d\u0003\u0002\u0002\u0002\u2217\u2219", + "\u0007O\u0002\u0002\u2218\u2217\u0003\u0002\u0002\u0002\u2218\u2219", + "\u0003\u0002\u0002\u0002\u2219\u221a\u0003\u0002\u0002\u0002\u221a\u221b", + "\u0005\u0490\u0249\u0002\u221b\u048f\u0003\u0002\u0002\u0002\u221c\u221e", + "\u0005\u0492\u024a\u0002\u221d\u221f\t.\u0002\u0002\u221e\u221d\u0003", + "\u0002\u0002\u0002\u221e\u221f\u0003\u0002\u0002\u0002\u221f\u0491\u0003", + "\u0002\u0002\u0002\u2220\u2238\u0005\u0494\u024b\u0002\u2221\u2223\u0007", + "v\u0002\u0002\u2222\u2224\u0007O\u0002\u0002\u2223\u2222\u0003\u0002", + "\u0002\u0002\u2223\u2224\u0003\u0002\u0002\u0002\u2224\u2236\u0003\u0002", + "\u0002\u0002\u2225\u2237\u0007P\u0002\u0002\u2226\u2237\u0007b\u0002", + "\u0002\u2227\u2237\u0007>\u0002\u0002\u2228\u2237\u0007\u0166\u0002", + "\u0002\u2229\u222a\u0007:\u0002\u0002\u222a\u222b\u0007B\u0002\u0002", + "\u222b\u2237\u0005\u0482\u0242\u0002\u222c\u222d\u0007\u010c\u0002\u0002", + "\u222d\u222e\u0007\u0004\u0002\u0002\u222e\u222f\u0005\u04fc\u027f\u0002", + "\u222f\u2230\u0007\u0005\u0002\u0002\u2230\u2237\u0003\u0002\u0002\u0002", + "\u2231\u2237\u0007\u00be\u0002\u0002\u2232\u2234\u0005\u0506\u0284\u0002", + "\u2233\u2232\u0003\u0002\u0002\u0002\u2233\u2234\u0003\u0002\u0002\u0002", + "\u2234\u2235\u0003\u0002\u0002\u0002\u2235\u2237\u0007\u01d7\u0002\u0002", + "\u2236\u2225\u0003\u0002\u0002\u0002\u2236\u2226\u0003\u0002\u0002\u0002", + "\u2236\u2227\u0003\u0002\u0002\u0002\u2236\u2228\u0003\u0002\u0002\u0002", + "\u2236\u2229\u0003\u0002\u0002\u0002\u2236\u222c\u0003\u0002\u0002\u0002", + "\u2236\u2231\u0003\u0002\u0002\u0002\u2236\u2233\u0003\u0002\u0002\u0002", + "\u2237\u2239\u0003\u0002\u0002\u0002\u2238\u2221\u0003\u0002\u0002\u0002", + "\u2238\u2239\u0003\u0002\u0002\u0002\u2239\u0493\u0003\u0002\u0002\u0002", + "\u223a\u2246\u0005\u0496\u024c\u0002\u223b\u223c\t/\u0002\u0002\u223c", + "\u2247\u0005\u0496\u024c\u0002\u223d\u223e\u0005\u04f4\u027b\u0002\u223e", + "\u2244\u0005\u04ea\u0276\u0002\u223f\u2245\u0005\u03bc\u01df\u0002\u2240", + "\u2241\u0007\u0004\u0002\u0002\u2241\u2242\u0005\u0482\u0242\u0002\u2242", + "\u2243\u0007\u0005\u0002\u0002\u2243\u2245\u0003\u0002\u0002\u0002\u2244", + "\u223f\u0003\u0002\u0002\u0002\u2244\u2240\u0003\u0002\u0002\u0002\u2245", + "\u2247\u0003\u0002\u0002\u0002\u2246\u223b\u0003\u0002\u0002\u0002\u2246", + "\u223d\u0003\u0002\u0002\u0002\u2246\u2247\u0003\u0002\u0002\u0002\u2247", + "\u0495\u0003\u0002\u0002\u0002\u2248\u2259\u0005\u0498\u024d\u0002\u2249", + "\u224b\u0007O\u0002\u0002\u224a\u2249\u0003\u0002\u0002\u0002\u224a", + "\u224b\u0003\u0002\u0002\u0002\u224b\u2254\u0003\u0002\u0002\u0002\u224c", + "\u2255\u0007z\u0002\u0002\u224d\u2255\u0007t\u0002\u0002\u224e\u224f", + "\u0007\u0081\u0002\u0002\u224f\u2255\u0007`\u0002\u0002\u2250\u2252", + "\u0007\u017c\u0002\u0002\u2251\u2253\u0007]\u0002\u0002\u2252\u2251", + "\u0003\u0002\u0002\u0002\u2252\u2253\u0003\u0002\u0002\u0002\u2253\u2255", + "\u0003\u0002\u0002\u0002\u2254\u224c\u0003\u0002\u0002\u0002\u2254\u224d", + "\u0003\u0002\u0002\u0002\u2254\u224e\u0003\u0002\u0002\u0002\u2254\u2250", + "\u0003\u0002\u0002\u0002\u2255\u2256\u0003\u0002\u0002\u0002\u2256\u2257", + "\u0005\u0498\u024d\u0002\u2257\u2258\u0005\u0480\u0241\u0002\u2258\u225a", + "\u0003\u0002\u0002\u0002\u2259\u224a\u0003\u0002\u0002\u0002\u2259\u225a", + "\u0003\u0002\u0002\u0002\u225a\u0497\u0003\u0002\u0002\u0002\u225b\u2261", + "\u0005\u049a\u024e\u0002\u225c\u225d\u0005\u04f0\u0279\u0002\u225d\u225e", + "\u0005\u049a\u024e\u0002\u225e\u2260\u0003\u0002\u0002\u0002\u225f\u225c", + "\u0003\u0002\u0002\u0002\u2260\u2263\u0003\u0002\u0002\u0002\u2261\u225f", + "\u0003\u0002\u0002\u0002\u2261\u2262\u0003\u0002\u0002\u0002\u2262\u0499", + "\u0003\u0002\u0002\u0002\u2263\u2261\u0003\u0002\u0002\u0002\u2264\u2266", + "\u0005\u04f0\u0279\u0002\u2265\u2264\u0003\u0002\u0002\u0002\u2265\u2266", + "\u0003\u0002\u0002\u0002\u2266\u2267\u0003\u0002\u0002\u0002\u2267\u2268", + "\u0005\u049c\u024f\u0002\u2268\u049b\u0003\u0002\u0002\u0002\u2269\u226e", + "\u0005\u049e\u0250\u0002\u226a\u226b\t0\u0002\u0002\u226b\u226d\u0005", + "\u049e\u0250\u0002\u226c\u226a\u0003\u0002\u0002\u0002\u226d\u2270\u0003", + "\u0002\u0002\u0002\u226e\u226c\u0003\u0002\u0002\u0002\u226e\u226f\u0003", + "\u0002\u0002\u0002\u226f\u049d\u0003\u0002\u0002\u0002\u2270\u226e\u0003", + "\u0002\u0002\u0002\u2271\u2276\u0005\u04a0\u0251\u0002\u2272\u2273\t", + "1\u0002\u0002\u2273\u2275\u0005\u04a0\u0251\u0002\u2274\u2272\u0003", + "\u0002\u0002\u0002\u2275\u2278\u0003\u0002\u0002\u0002\u2276\u2274\u0003", + "\u0002\u0002\u0002\u2276\u2277\u0003\u0002\u0002\u0002\u2277\u049f\u0003", + "\u0002\u0002\u0002\u2278\u2276\u0003\u0002\u0002\u0002\u2279\u227c\u0005", + "\u04a2\u0252\u0002\u227a\u227b\u0007\u0011\u0002\u0002\u227b\u227d\u0005", + "\u0482\u0242\u0002\u227c\u227a\u0003\u0002\u0002\u0002\u227c\u227d\u0003", + "\u0002\u0002\u0002\u227d\u04a1\u0003\u0002\u0002\u0002\u227e\u2280\t", + "0\u0002\u0002\u227f\u227e\u0003\u0002\u0002\u0002\u227f\u2280\u0003", + "\u0002\u0002\u0002\u2280\u2281\u0003\u0002\u0002\u0002\u2281\u2282\u0005", + "\u04a4\u0253\u0002\u2282\u04a3\u0003\u0002\u0002\u0002\u2283\u2288\u0005", + "\u04a6\u0254\u0002\u2284\u2285\u0007\u0090\u0002\u0002\u2285\u2286\u0007", + "\u019b\u0002\u0002\u2286\u2287\u0007\u017b\u0002\u0002\u2287\u2289\u0005", + "\u0482\u0242\u0002\u2288\u2284\u0003\u0002\u0002\u0002\u2288\u2289\u0003", + "\u0002\u0002\u0002\u2289\u04a5\u0003\u0002\u0002\u0002\u228a\u228d\u0005", + "\u04a8\u0255\u0002\u228b\u228c\u0007-\u0002\u0002\u228c\u228e\u0005", + "\u020e\u0108\u0002\u228d\u228b\u0003\u0002\u0002\u0002\u228d\u228e\u0003", + "\u0002\u0002\u0002\u228e\u04a7\u0003\u0002\u0002\u0002\u228f\u2294\u0005", + "\u04ac\u0257\u0002\u2290\u2291\u0007\u001c\u0002\u0002\u2291\u2293\u0005", + "\u0456\u022c\u0002\u2292\u2290\u0003\u0002\u0002\u0002\u2293\u2296\u0003", + "\u0002\u0002\u0002\u2294\u2292\u0003\u0002\u0002\u0002\u2294\u2295\u0003", + "\u0002\u0002\u0002\u2295\u04a9\u0003\u0002\u0002\u0002\u2296\u2294\u0003", + "\u0002\u0002\u0002\u2297\u2298\b\u0256\u0001\u0002\u2298\u229f\u0005", + "\u04ac\u0257\u0002\u2299\u229a\t0\u0002\u0002\u229a\u229f\u0005\u04aa", + "\u0256\u000b\u229b\u229c\u0005\u04f0\u0279\u0002\u229c\u229d\u0005\u04aa", + "\u0256\u0005\u229d\u229f\u0003\u0002\u0002\u0002\u229e\u2297\u0003\u0002", + "\u0002\u0002\u229e\u2299\u0003\u0002\u0002\u0002\u229e\u229b\u0003\u0002", + "\u0002\u0002\u229f\u22c7\u0003\u0002\u0002\u0002\u22a0\u22a1\f\n\u0002", + "\u0002\u22a1\u22a2\u0007\u0011\u0002\u0002\u22a2\u22c6\u0005\u04aa\u0256", + "\u000b\u22a3\u22a4\f\t\u0002\u0002\u22a4\u22a5\t1\u0002\u0002\u22a5", + "\u22c6\u0005\u04aa\u0256\n\u22a6\u22a7\f\b\u0002\u0002\u22a7\u22a8\t", + "0\u0002\u0002\u22a8\u22c6\u0005\u04aa\u0256\t\u22a9\u22aa\f\u0007\u0002", + "\u0002\u22aa\u22ab\u0005\u04f0\u0279\u0002\u22ab\u22ac\u0005\u04aa\u0256", + "\b\u22ac\u22c6\u0003\u0002\u0002\u0002\u22ad\u22ae\f\u0006\u0002\u0002", + "\u22ae\u22af\t/\u0002\u0002\u22af\u22c6\u0005\u04aa\u0256\u0007\u22b0", + "\u22b1\f\f\u0002\u0002\u22b1\u22b2\u0007\u001c\u0002\u0002\u22b2\u22c6", + "\u0005\u0456\u022c\u0002\u22b3\u22b4\f\u0004\u0002\u0002\u22b4\u22c6", + "\u0005\u04f0\u0279\u0002\u22b5\u22b6\f\u0003\u0002\u0002\u22b6\u22b8", + "\u0007v\u0002\u0002\u22b7\u22b9\u0007O\u0002\u0002\u22b8\u22b7\u0003", + "\u0002\u0002\u0002\u22b8\u22b9\u0003\u0002\u0002\u0002\u22b9\u22c3\u0003", + "\u0002\u0002\u0002\u22ba\u22bb\u0007:\u0002\u0002\u22bb\u22bc\u0007", + "B\u0002\u0002\u22bc\u22c4\u0005\u04aa\u0256\u0002\u22bd\u22be\u0007", + "\u010c\u0002\u0002\u22be\u22bf\u0007\u0004\u0002\u0002\u22bf\u22c0\u0005", + "\u04fc\u027f\u0002\u22c0\u22c1\u0007\u0005\u0002\u0002\u22c1\u22c4\u0003", + "\u0002\u0002\u0002\u22c2\u22c4\u0007\u00be\u0002\u0002\u22c3\u22ba\u0003", + "\u0002\u0002\u0002\u22c3\u22bd\u0003\u0002\u0002\u0002\u22c3\u22c2\u0003", + "\u0002\u0002\u0002\u22c4\u22c6\u0003\u0002\u0002\u0002\u22c5\u22a0\u0003", + "\u0002\u0002\u0002\u22c5\u22a3\u0003\u0002\u0002\u0002\u22c5\u22a6\u0003", + "\u0002\u0002\u0002\u22c5\u22a9\u0003\u0002\u0002\u0002\u22c5\u22ad\u0003", + "\u0002\u0002\u0002\u22c5\u22b0\u0003\u0002\u0002\u0002\u22c5\u22b3\u0003", + "\u0002\u0002\u0002\u22c5\u22b5\u0003\u0002\u0002\u0002\u22c6\u22c9\u0003", + "\u0002\u0002\u0002\u22c7\u22c5\u0003\u0002\u0002\u0002\u22c7\u22c8\u0003", + "\u0002\u0002\u0002\u22c8\u04ab\u0003\u0002\u0002\u0002\u22c9\u22c7\u0003", + "\u0002\u0002\u0002\u22ca\u22cb\u0007\u0185\u0002\u0002\u22cb\u22ef\u0005", + "\u03bc\u01df\u0002\u22cc\u22cf\u0007%\u0002\u0002\u22cd\u22d0\u0005", + "\u03bc\u01df\u0002\u22ce\u22d0\u0005\u04fe\u0280\u0002\u22cf\u22cd\u0003", + "\u0002\u0002\u0002\u22cf\u22ce\u0003\u0002\u0002\u0002\u22d0\u22ef\u0003", + "\u0002\u0002\u0002\u22d1\u22d2\u0007\u001e\u0002\u0002\u22d2\u22ef\u0005", + "\u0524\u0293\u0002\u22d3\u22d4\u0007\u01cf\u0002\u0002\u22d4\u22d5\u0007", + "\u0004\u0002\u0002\u22d5\u22d6\u0005\u04f6\u027c\u0002\u22d6\u22d7\u0007", + "\u0005\u0002\u0002\u22d7\u22ef\u0003\u0002\u0002\u0002\u22d8\u22d9\u0007", + "d\u0002\u0002\u22d9\u22ef\u0005\u03bc\u01df\u0002\u22da\u22ef\u0005", + "\u051c\u028f\u0002\u22db\u22ef\u0005\u053a\u029e\u0002\u22dc\u22ef\u0005", + "\u04ae\u0258\u0002\u22dd\u22de\u0007\u0004\u0002\u0002\u22de\u22df\u0005", + "\u0482\u0242\u0002\u22df\u22e0\u0007\u0005\u0002\u0002\u22e0\u22e1\u0005", + "\u0524\u0293\u0002\u22e1\u22ef\u0003\u0002\u0002\u0002\u22e2\u22ef\u0005", + "\u0512\u028a\u0002\u22e3\u22ef\u0005\u04b2\u025a\u0002\u22e4\u22e6\u0005", + "\u03bc\u01df\u0002\u22e5\u22e7\u0005\u0522\u0292\u0002\u22e6\u22e5\u0003", + "\u0002\u0002\u0002\u22e6\u22e7\u0003\u0002\u0002\u0002\u22e7\u22ef\u0003", + "\u0002\u0002\u0002\u22e8\u22ef\u0005\u04e6\u0274\u0002\u22e9\u22ef\u0005", + "\u04e8\u0275\u0002\u22ea\u22eb\u0005\u04e4\u0273\u0002\u22eb\u22ec\u0007", + "\u007f\u0002\u0002\u22ec\u22ed\u0005\u04e4\u0273\u0002\u22ed\u22ef\u0003", + "\u0002\u0002\u0002\u22ee\u22ca\u0003\u0002\u0002\u0002\u22ee\u22cc\u0003", + "\u0002\u0002\u0002\u22ee\u22d1\u0003\u0002\u0002\u0002\u22ee\u22d3\u0003", + "\u0002\u0002\u0002\u22ee\u22d8\u0003\u0002\u0002\u0002\u22ee\u22da\u0003", + "\u0002\u0002\u0002\u22ee\u22db\u0003\u0002\u0002\u0002\u22ee\u22dc\u0003", + "\u0002\u0002\u0002\u22ee\u22dd\u0003\u0002\u0002\u0002\u22ee\u22e2\u0003", + "\u0002\u0002\u0002\u22ee\u22e3\u0003\u0002\u0002\u0002\u22ee\u22e4\u0003", + "\u0002\u0002\u0002\u22ee\u22e8\u0003\u0002\u0002\u0002\u22ee\u22e9\u0003", + "\u0002\u0002\u0002\u22ee\u22ea\u0003\u0002\u0002\u0002\u22ef\u04ad\u0003", + "\u0002\u0002\u0002\u22f0\u22f1\u0007\u021b\u0002\u0002\u22f1\u04af\u0003", + "\u0002\u0002\u0002\u22f2\u22f3\u0005\u0538\u029d\u0002\u22f3\u2306\u0007", + "\u0004\u0002\u0002\u22f4\u22f8\u0005\u04f8\u027d\u0002\u22f5\u22f6\u0007", + "\b\u0002\u0002\u22f6\u22f7\u0007g\u0002\u0002\u22f7\u22f9\u0005\u04fa", + "\u027e\u0002\u22f8\u22f5\u0003\u0002\u0002\u0002\u22f8\u22f9\u0003\u0002", + "\u0002\u0002\u22f9\u22fa\u0003\u0002\u0002\u0002\u22fa\u22fb\u0005\u03e0", + "\u01f1\u0002\u22fb\u2307\u0003\u0002\u0002\u0002\u22fc\u22fd\u0007g", + "\u0002\u0002\u22fd\u22fe\u0005\u04fa\u027e\u0002\u22fe\u22ff\u0005\u03e0", + "\u01f1\u0002\u22ff\u2307\u0003\u0002\u0002\u0002\u2300\u2301\t2\u0002", + "\u0002\u2301\u2302\u0005\u04f8\u027d\u0002\u2302\u2303\u0005\u03e0\u01f1", + "\u0002\u2303\u2307\u0003\u0002\u0002\u0002\u2304\u2307\u0007\u000b\u0002", + "\u0002\u2305\u2307\u0003\u0002\u0002\u0002\u2306\u22f4\u0003\u0002\u0002", + "\u0002\u2306\u22fc\u0003\u0002\u0002\u0002\u2306\u2300\u0003\u0002\u0002", + "\u0002\u2306\u2304\u0003\u0002\u0002\u0002\u2306\u2305\u0003\u0002\u0002", + "\u0002\u2307\u2308\u0003\u0002\u0002\u0002\u2308\u2309\u0007\u0005\u0002", + "\u0002\u2309\u04b1\u0003\u0002\u0002\u0002\u230a\u230b\u0005\u04b0\u0259", + "\u0002\u230b\u230c\u0005\u04ca\u0266\u0002\u230c\u230d\u0005\u04cc\u0267", + "\u0002\u230d\u230e\u0005\u04d4\u026b\u0002\u230e\u2311\u0003\u0002\u0002", + "\u0002\u230f\u2311\u0005\u04b6\u025c\u0002\u2310\u230a\u0003\u0002\u0002", + "\u0002\u2310\u230f\u0003\u0002\u0002\u0002\u2311\u04b3\u0003\u0002\u0002", + "\u0002\u2312\u2315\u0005\u04b0\u0259\u0002\u2313\u2315\u0005\u04b6\u025c", + "\u0002\u2314\u2312\u0003\u0002\u0002\u0002\u2314\u2313\u0003\u0002\u0002", + "\u0002\u2315\u04b5\u0003\u0002\u0002\u0002\u2316\u2317\u0007n\u0002", + "\u0002\u2317\u2318\u0007@\u0002\u0002\u2318\u2319\u0007\u0004\u0002", + "\u0002\u2319\u231a\u0005\u0482\u0242\u0002\u231a\u231b\u0007\u0005\u0002", + "\u0002\u231b\u23c8\u0003\u0002\u0002\u0002\u231c\u23c8\u00072\u0002", + "\u0002\u231d\u2322\u00074\u0002\u0002\u231e\u231f\u0007\u0004\u0002", + "\u0002\u231f\u2320\u0005\u0542\u02a2\u0002\u2320\u2321\u0007\u0005\u0002", + "\u0002\u2321\u2323\u0003\u0002\u0002\u0002\u2322\u231e\u0003\u0002\u0002", + "\u0002\u2322\u2323\u0003\u0002\u0002\u0002\u2323\u23c8\u0003\u0002\u0002", + "\u0002\u2324\u2329\u00075\u0002\u0002\u2325\u2326\u0007\u0004\u0002", + "\u0002\u2326\u2327\u0005\u0542\u02a2\u0002\u2327\u2328\u0007\u0005\u0002", + "\u0002\u2328\u232a\u0003\u0002\u0002\u0002\u2329\u2325\u0003\u0002\u0002", + "\u0002\u2329\u232a\u0003\u0002\u0002\u0002\u232a\u23c8\u0003\u0002\u0002", + "\u0002\u232b\u2330\u0007M\u0002\u0002\u232c\u232d\u0007\u0004\u0002", + "\u0002\u232d\u232e\u0005\u0542\u02a2\u0002\u232e\u232f\u0007\u0005\u0002", + "\u0002\u232f\u2331\u0003\u0002\u0002\u0002\u2330\u232c\u0003\u0002\u0002", + "\u0002\u2330\u2331\u0003\u0002\u0002\u0002\u2331\u23c8\u0003\u0002\u0002", + "\u0002\u2332\u2337\u0007N\u0002\u0002\u2333\u2334\u0007\u0004\u0002", + "\u0002\u2334\u2335\u0005\u0542\u02a2\u0002\u2335\u2336\u0007\u0005\u0002", + "\u0002\u2336\u2338\u0003\u0002\u0002\u0002\u2337\u2333\u0003\u0002\u0002", + "\u0002\u2337\u2338\u0003\u0002\u0002\u0002\u2338\u23c8\u0003\u0002\u0002", + "\u0002\u2339\u23c8\u00073\u0002\u0002\u233a\u23c8\u00076\u0002\u0002", + "\u233b\u23c8\u0007[\u0002\u0002\u233c\u23c8\u0007e\u0002\u0002\u233d", + "\u23c8\u00071\u0002\u0002\u233e\u23c8\u0007q\u0002\u0002\u233f\u2340", + "\u0007+\u0002\u0002\u2340\u2341\u0007\u0004\u0002\u0002\u2341\u2342", + "\u0005\u0482\u0242\u0002\u2342\u2343\u0007&\u0002\u0002\u2343\u2344", + "\u0005\u0456\u022c\u0002\u2344\u2345\u0007\u0005\u0002\u0002\u2345\u23c8", + "\u0003\u0002\u0002\u0002\u2346\u2347\u0007\u0186\u0002\u0002\u2347\u2348", + "\u0007\u0004\u0002\u0002\u2348\u2349\u0005\u0502\u0282\u0002\u2349\u234a", + "\u0007\u0005\u0002\u0002\u234a\u23c8\u0003\u0002\u0002\u0002\u234b\u234c", + "\u0007\u01e2\u0002\u0002\u234c\u234d\u0007\u0004\u0002\u0002\u234d\u2350", + "\u0005\u0482\u0242\u0002\u234e\u234f\u0007\b\u0002\u0002\u234f\u2351", + "\u0005\u0506\u0284\u0002\u2350\u234e\u0003\u0002\u0002\u0002\u2350\u2351", + "\u0003\u0002\u0002\u0002\u2351\u2352\u0003\u0002\u0002\u0002\u2352\u2353", + "\u0007\u0005\u0002\u0002\u2353\u23c8\u0003\u0002\u0002\u0002\u2354\u2355", + "\u0007\u0193\u0002\u0002\u2355\u2356\u0007\u0004\u0002\u0002\u2356\u2357", + "\u0005\u0508\u0285\u0002\u2357\u2358\u0007\u0005\u0002\u0002\u2358\u23c8", + "\u0003\u0002\u0002\u0002\u2359\u235a\u0007\u0194\u0002\u0002\u235a\u235b", + "\u0007\u0004\u0002\u0002\u235b\u235c\u0005\u050a\u0286\u0002\u235c\u235d", + "\u0007\u0005\u0002\u0002\u235d\u23c8\u0003\u0002\u0002\u0002\u235e\u235f", + "\u0007\u019a\u0002\u0002\u235f\u2360\u0007\u0004\u0002\u0002\u2360\u2361", + "\u0005\u050c\u0287\u0002\u2361\u2362\u0007\u0005\u0002\u0002\u2362\u23c8", + "\u0003\u0002\u0002\u0002\u2363\u2364\u0007\u019d\u0002\u0002\u2364\u2365", + "\u0007\u0004\u0002\u0002\u2365\u2366\u0005\u0482\u0242\u0002\u2366\u2367", + "\u0007&\u0002\u0002\u2367\u2368\u0005\u0456\u022c\u0002\u2368\u2369", + "\u0007\u0005\u0002\u0002\u2369\u23c8\u0003\u0002\u0002\u0002\u236a\u236b", + "\u0007\u019e\u0002\u0002\u236b\u236d\u0007\u0004\u0002\u0002\u236c\u236e", + "\t3\u0002\u0002\u236d\u236c\u0003\u0002\u0002\u0002\u236d\u236e\u0003", + "\u0002\u0002\u0002\u236e\u236f\u0003\u0002\u0002\u0002\u236f\u2370\u0005", + "\u050e\u0288\u0002\u2370\u2371\u0007\u0005\u0002\u0002\u2371\u23c8\u0003", + "\u0002\u0002\u0002\u2372\u2373\u0007\u0191\u0002\u0002\u2373\u2374\u0007", + "\u0004\u0002\u0002\u2374\u2375\u0005\u0482\u0242\u0002\u2375\u2376\u0007", + "\b\u0002\u0002\u2376\u2377\u0005\u0482\u0242\u0002\u2377\u2378\u0007", + "\u0005\u0002\u0002\u2378\u23c8\u0003\u0002\u0002\u0002\u2379\u237a\u0007", + "\u0182\u0002\u0002\u237a\u237b\u0007\u0004\u0002\u0002\u237b\u237c\u0005", + "\u04f6\u027c\u0002\u237c\u237d\u0007\u0005\u0002\u0002\u237d\u23c8\u0003", + "\u0002\u0002\u0002\u237e\u237f\u0007\u0188\u0002\u0002\u237f\u2380\u0007", + "\u0004\u0002\u0002\u2380\u2381\u0005\u04f6\u027c\u0002\u2381\u2382\u0007", + "\u0005\u0002\u0002\u2382\u23c8\u0003\u0002\u0002\u0002\u2383\u2384\u0007", + "\u018d\u0002\u0002\u2384\u2385\u0007\u0004\u0002\u0002\u2385\u2386\u0005", + "\u04f6\u027c\u0002\u2386\u2387\u0007\u0005\u0002\u0002\u2387\u23c8\u0003", + "\u0002\u0002\u0002\u2388\u2389\u0007\u01a2\u0002\u0002\u2389\u238a\u0007", + "\u0004\u0002\u0002\u238a\u238b\u0005\u04f6\u027c\u0002\u238b\u238c\u0007", + "\u0005\u0002\u0002\u238c\u23c8\u0003\u0002\u0002\u0002\u238d\u238e\u0007", + "\u01a3\u0002\u0002\u238e\u238f\u0007\u0004\u0002\u0002\u238f\u2390\u0007", + "\u0103\u0002\u0002\u2390\u2396\u0005\u0558\u02ad\u0002\u2391\u2394\u0007", + "\b\u0002\u0002\u2392\u2395\u0005\u04bc\u025f\u0002\u2393\u2395\u0005", + "\u04f6\u027c\u0002\u2394\u2392\u0003\u0002\u0002\u0002\u2394\u2393\u0003", + "\u0002\u0002\u0002\u2395\u2397\u0003\u0002\u0002\u0002\u2396\u2391\u0003", + "\u0002\u0002\u0002\u2396\u2397\u0003\u0002\u0002\u0002\u2397\u2398\u0003", + "\u0002\u0002\u0002\u2398\u2399\u0007\u0005\u0002\u0002\u2399\u23c8\u0003", + "\u0002\u0002\u0002\u239a\u239b\u0007\u01a4\u0002\u0002\u239b\u239c\u0007", + "\u0004\u0002\u0002\u239c\u239d\u0005\u04ac\u0257\u0002\u239d\u239e\u0005", + "\u04c6\u0264\u0002\u239e\u239f\u0007\u0005\u0002\u0002\u239f\u23c8\u0003", + "\u0002\u0002\u0002\u23a0\u23a1\u0007\u01a5\u0002\u0002\u23a1\u23a2\u0007", + "\u0004\u0002\u0002\u23a2\u23a3\u0005\u04be\u0260\u0002\u23a3\u23a4\u0007", + "\u0005\u0002\u0002\u23a4\u23c8\u0003\u0002\u0002\u0002\u23a5\u23a6\u0007", + "\u01a6\u0002\u0002\u23a6\u23a7\u0007\u0004\u0002\u0002\u23a7\u23a8\u0005", + "\u04c2\u0262\u0002\u23a8\u23a9\u0005\u0482\u0242\u0002\u23a9\u23aa\u0005", + "\u04c4\u0263\u0002\u23aa\u23ab\u0007\u0005\u0002\u0002\u23ab\u23c8\u0003", + "\u0002\u0002\u0002\u23ac\u23ad\u0007\u01a7\u0002\u0002\u23ad\u23ae\u0007", + "\u0004\u0002\u0002\u23ae\u23af\u0007\u0103\u0002\u0002\u23af\u23b2\u0005", + "\u0558\u02ad\u0002\u23b0\u23b1\u0007\b\u0002\u0002\u23b1\u23b3\u0005", + "\u0482\u0242\u0002\u23b2\u23b0\u0003\u0002\u0002\u0002\u23b2\u23b3\u0003", + "\u0002\u0002\u0002\u23b3\u23b4\u0003\u0002\u0002\u0002\u23b4\u23b5\u0007", + "\u0005\u0002\u0002\u23b5\u23c8\u0003\u0002\u0002\u0002\u23b6\u23b7\u0007", + "\u01a8\u0002\u0002\u23b7\u23b8\u0007\u0004\u0002\u0002\u23b8\u23b9\u0007", + "\u0178\u0002\u0002\u23b9\u23ba\u0005\u0482\u0242\u0002\u23ba\u23bb\u0007", + "\b\u0002\u0002\u23bb\u23bc\u0005\u04b8\u025d\u0002\u23bc\u23bd\u0005", + "\u04ba\u025e\u0002\u23bd\u23be\u0007\u0005\u0002\u0002\u23be\u23c8\u0003", + "\u0002\u0002\u0002\u23bf\u23c0\u0007\u01a9\u0002\u0002\u23c0\u23c1\u0007", + "\u0004\u0002\u0002\u23c1\u23c2\u0005\u04c2\u0262\u0002\u23c2\u23c3\u0005", + "\u0482\u0242\u0002\u23c3\u23c4\u0007&\u0002\u0002\u23c4\u23c5\u0005", + "\u045a\u022e\u0002\u23c5\u23c6\u0007\u0005\u0002\u0002\u23c6\u23c8\u0003", + "\u0002\u0002\u0002\u23c7\u2316\u0003\u0002\u0002\u0002\u23c7\u231c\u0003", + "\u0002\u0002\u0002\u23c7\u231d\u0003\u0002\u0002\u0002\u23c7\u2324\u0003", + "\u0002\u0002\u0002\u23c7\u232b\u0003\u0002\u0002\u0002\u23c7\u2332\u0003", + "\u0002\u0002\u0002\u23c7\u2339\u0003\u0002\u0002\u0002\u23c7\u233a\u0003", + "\u0002\u0002\u0002\u23c7\u233b\u0003\u0002\u0002\u0002\u23c7\u233c\u0003", + "\u0002\u0002\u0002\u23c7\u233d\u0003\u0002\u0002\u0002\u23c7\u233e\u0003", + "\u0002\u0002\u0002\u23c7\u233f\u0003\u0002\u0002\u0002\u23c7\u2346\u0003", + "\u0002\u0002\u0002\u23c7\u234b\u0003\u0002\u0002\u0002\u23c7\u2354\u0003", + "\u0002\u0002\u0002\u23c7\u2359\u0003\u0002\u0002\u0002\u23c7\u235e\u0003", + "\u0002\u0002\u0002\u23c7\u2363\u0003\u0002\u0002\u0002\u23c7\u236a\u0003", + "\u0002\u0002\u0002\u23c7\u2372\u0003\u0002\u0002\u0002\u23c7\u2379\u0003", + "\u0002\u0002\u0002\u23c7\u237e\u0003\u0002\u0002\u0002\u23c7\u2383\u0003", + "\u0002\u0002\u0002\u23c7\u2388\u0003\u0002\u0002\u0002\u23c7\u238d\u0003", + "\u0002\u0002\u0002\u23c7\u239a\u0003\u0002\u0002\u0002\u23c7\u23a0\u0003", + "\u0002\u0002\u0002\u23c7\u23a5\u0003\u0002\u0002\u0002\u23c7\u23ac\u0003", + "\u0002\u0002\u0002\u23c7\u23b6\u0003\u0002\u0002\u0002\u23c7\u23bf\u0003", + "\u0002\u0002\u0002\u23c8\u04b7\u0003\u0002\u0002\u0002\u23c9\u23ca\u0007", + "\u0170\u0002\u0002\u23ca\u23cf\u0005\u0482\u0242\u0002\u23cb\u23cc\u0007", + "\u0170\u0002\u0002\u23cc\u23cd\u0007\u0106\u0002\u0002\u23cd\u23cf\u0007", + "\u01bb\u0002\u0002\u23ce\u23c9\u0003\u0002\u0002\u0002\u23ce\u23cb\u0003", + "\u0002\u0002\u0002\u23cf\u04b9\u0003\u0002\u0002\u0002\u23d0\u23d1\u0007", + "\b\u0002\u0002\u23d1\u23d2\u0007\u014c\u0002\u0002\u23d2\u23dc\u0007", + "\u017a\u0002\u0002\u23d3\u23d4\u0007\b\u0002\u0002\u23d4\u23d5\u0007", + "\u014c\u0002\u0002\u23d5\u23dc\u0007\u0106\u0002\u0002\u23d6\u23d7\u0007", + "\b\u0002\u0002\u23d7\u23d8\u0007\u014c\u0002\u0002\u23d8\u23d9\u0007", + "\u0106\u0002\u0002\u23d9\u23dc\u0007\u01bb\u0002\u0002\u23da\u23dc\u0003", + "\u0002\u0002\u0002\u23db\u23d0\u0003\u0002\u0002\u0002\u23db\u23d3\u0003", + "\u0002\u0002\u0002\u23db\u23d6\u0003\u0002\u0002\u0002\u23db\u23da\u0003", + "\u0002\u0002\u0002\u23dc\u04bb\u0003\u0002\u0002\u0002\u23dd\u23de\u0007", + "\u01a1\u0002\u0002\u23de\u23df\u0007\u0004\u0002\u0002\u23df\u23e0\u0005", + "\u04be\u0260\u0002\u23e0\u23e1\u0007\u0005\u0002\u0002\u23e1\u04bd\u0003", + "\u0002\u0002\u0002\u23e2\u23e7\u0005\u04c0\u0261\u0002\u23e3\u23e4\u0007", + "\b\u0002\u0002\u23e4\u23e6\u0005\u04c0\u0261\u0002\u23e5\u23e3\u0003", + "\u0002\u0002\u0002\u23e6\u23e9\u0003\u0002\u0002\u0002\u23e7\u23e5\u0003", + "\u0002\u0002\u0002\u23e7\u23e8\u0003\u0002\u0002\u0002\u23e8\u04bf\u0003", + "\u0002\u0002\u0002\u23e9\u23e7\u0003\u0002\u0002\u0002\u23ea\u23ed\u0005", + "\u0482\u0242\u0002\u23eb\u23ec\u0007&\u0002\u0002\u23ec\u23ee\u0005", + "\u0558\u02ad\u0002\u23ed\u23eb\u0003\u0002\u0002\u0002\u23ed\u23ee\u0003", + "\u0002\u0002\u0002\u23ee\u04c1\u0003\u0002\u0002\u0002\u23ef\u23f0\t", + "4\u0002\u0002\u23f0\u04c3\u0003\u0002\u0002\u0002\u23f1\u23f2\u0007", + "\u011d\u0002\u0002\u23f2\u23f7\u0007\u0173\u0002\u0002\u23f3\u23f4\u0007", + "\u0154\u0002\u0002\u23f4\u23f7\u0007\u0173\u0002\u0002\u23f5\u23f7\u0003", + "\u0002\u0002\u0002\u23f6\u23f1\u0003\u0002\u0002\u0002\u23f6\u23f3\u0003", + "\u0002\u0002\u0002\u23f6\u23f5\u0003\u0002\u0002\u0002\u23f7\u04c5\u0003", + "\u0002\u0002\u0002\u23f8\u23f9\u0007\u0117\u0002\u0002\u23f9\u2408\u0005", + "\u04ac\u0257\u0002\u23fa\u23fb\u0007\u0117\u0002\u0002\u23fb\u23fc\u0005", + "\u04ac\u0257\u0002\u23fc\u23fd\u0005\u04c8\u0265\u0002\u23fd\u2408\u0003", + "\u0002\u0002\u0002\u23fe\u23ff\u0007\u0117\u0002\u0002\u23ff\u2400\u0005", + "\u04c8\u0265\u0002\u2400\u2401\u0005\u04ac\u0257\u0002\u2401\u2408\u0003", + "\u0002\u0002\u0002\u2402\u2403\u0007\u0117\u0002\u0002\u2403\u2404\u0005", + "\u04c8\u0265\u0002\u2404\u2405\u0005\u04ac\u0257\u0002\u2405\u2406\u0005", + "\u04c8\u0265\u0002\u2406\u2408\u0003\u0002\u0002\u0002\u2407\u23f8\u0003", + "\u0002\u0002\u0002\u2407\u23fa\u0003\u0002\u0002\u0002\u2407\u23fe\u0003", + "\u0002\u0002\u0002\u2407\u2402\u0003\u0002\u0002\u0002\u2408\u04c7\u0003", + "\u0002\u0002\u0002\u2409\u240a\u0007\u0095\u0002\u0002\u240a\u240b\t", + "5\u0002\u0002\u240b\u04c9\u0003\u0002\u0002\u0002\u240c\u240d\u0007", + "\u01d8\u0002\u0002\u240d\u240e\u0007D\u0002\u0002\u240e\u240f\u0007", + "\u0004\u0002\u0002\u240f\u2410\u0005\u03e2\u01f2\u0002\u2410\u2411\u0007", + "\u0005\u0002\u0002\u2411\u2414\u0003\u0002\u0002\u0002\u2412\u2414\u0003", + "\u0002\u0002\u0002\u2413\u240c\u0003\u0002\u0002\u0002\u2413\u2412\u0003", + "\u0002\u0002\u0002\u2414\u04cb\u0003\u0002\u0002\u0002\u2415\u2416\u0007", + "\u01d9\u0002\u0002\u2416\u2417\u0007\u0004\u0002\u0002\u2417\u2418\u0007", + "i\u0002\u0002\u2418\u2419\u0005\u0482\u0242\u0002\u2419\u241a\u0007", + "\u0005\u0002\u0002\u241a\u241d\u0003\u0002\u0002\u0002\u241b\u241d\u0003", + "\u0002\u0002\u0002\u241c\u2415\u0003\u0002\u0002\u0002\u241c\u241b\u0003", + "\u0002\u0002\u0002\u241d\u04cd\u0003\u0002\u0002\u0002\u241e\u241f\u0007", + "j\u0002\u0002\u241f\u2422\u0005\u04d0\u0269\u0002\u2420\u2422\u0003", + "\u0002\u0002\u0002\u2421\u241e\u0003\u0002\u0002\u0002\u2421\u2420\u0003", + "\u0002\u0002\u0002\u2422\u04cf\u0003\u0002\u0002\u0002\u2423\u2428\u0005", + "\u04d2\u026a\u0002\u2424\u2425\u0007\b\u0002\u0002\u2425\u2427\u0005", + "\u04d2\u026a\u0002\u2426\u2424\u0003\u0002\u0002\u0002\u2427\u242a\u0003", + "\u0002\u0002\u0002\u2428\u2426\u0003\u0002\u0002\u0002\u2428\u2429\u0003", + "\u0002\u0002\u0002\u2429\u04d1\u0003\u0002\u0002\u0002\u242a\u2428\u0003", + "\u0002\u0002\u0002\u242b\u242c\u0005\u0552\u02aa\u0002\u242c\u242d\u0007", + "&\u0002\u0002\u242d\u242e\u0005\u04d6\u026c\u0002\u242e\u04d3\u0003", + "\u0002\u0002\u0002\u242f\u2432\u0007~\u0002\u0002\u2430\u2433\u0005", + "\u04d6\u026c\u0002\u2431\u2433\u0005\u0552\u02aa\u0002\u2432\u2430\u0003", + "\u0002\u0002\u0002\u2432\u2431\u0003\u0002\u0002\u0002\u2433\u2436\u0003", + "\u0002\u0002\u0002\u2434\u2436\u0003\u0002\u0002\u0002\u2435\u242f\u0003", + "\u0002\u0002\u0002\u2435\u2434\u0003\u0002\u0002\u0002\u2436\u04d5\u0003", + "\u0002\u0002\u0002\u2437\u2438\u0007\u0004\u0002\u0002\u2438\u2439\u0005", + "\u04d8\u026d\u0002\u2439\u243a\u0005\u04da\u026e\u0002\u243a\u243b\u0005", + "\u03e0\u01f1\u0002\u243b\u243c\u0005\u04dc\u026f\u0002\u243c\u243d\u0007", + "\u0005\u0002\u0002\u243d\u04d7\u0003\u0002\u0002\u0002\u243e\u2441\u0005", + "\u0552\u02aa\u0002\u243f\u2441\u0003\u0002\u0002\u0002\u2440\u243e\u0003", + "\u0002\u0002\u0002\u2440\u243f\u0003\u0002\u0002\u0002\u2441\u04d9\u0003", + "\u0002\u0002\u0002\u2442\u2443\u0007\u0116\u0002\u0002\u2443\u2444\u0007", + "\u0095\u0002\u0002\u2444\u2447\u0005\u04f6\u027c\u0002\u2445\u2447\u0003", + "\u0002\u0002\u0002\u2446\u2442\u0003\u0002\u0002\u0002\u2446\u2445\u0003", + "\u0002\u0002\u0002\u2447\u04db\u0003\u0002\u0002\u0002\u2448\u2449\u0007", + "\u0124\u0002\u0002\u2449\u244a\u0005\u04de\u0270\u0002\u244a\u244b\u0005", + "\u04e2\u0272\u0002\u244b\u2456\u0003\u0002\u0002\u0002\u244c\u244d\u0007", + "\u0139\u0002\u0002\u244d\u244e\u0005\u04de\u0270\u0002\u244e\u244f\u0005", + "\u04e2\u0272\u0002\u244f\u2456\u0003\u0002\u0002\u0002\u2450\u2451\u0007", + "\u01da\u0002\u0002\u2451\u2452\u0005\u04de\u0270\u0002\u2452\u2453\u0005", + "\u04e2\u0272\u0002\u2453\u2456\u0003\u0002\u0002\u0002\u2454\u2456\u0003", + "\u0002\u0002\u0002\u2455\u2448\u0003\u0002\u0002\u0002\u2455\u244c\u0003", + "\u0002\u0002\u0002\u2455\u2450\u0003\u0002\u0002\u0002\u2455\u2454\u0003", + "\u0002\u0002\u0002\u2456\u04dd\u0003\u0002\u0002\u0002\u2457\u245e\u0005", + "\u04e0\u0271\u0002\u2458\u2459\u0007\u017c\u0002\u0002\u2459\u245a\u0005", + "\u04e0\u0271\u0002\u245a\u245b\u0007#\u0002\u0002\u245b\u245c\u0005", + "\u04e0\u0271\u0002\u245c\u245e\u0003\u0002\u0002\u0002\u245d\u2457\u0003", + "\u0002\u0002\u0002\u245d\u2458\u0003\u0002\u0002\u0002\u245e\u04df\u0003", + "\u0002\u0002\u0002\u245f\u2460\u0007\u0163\u0002\u0002\u2460\u2467\t", + "6\u0002\u0002\u2461\u2462\u0007\u01ab\u0002\u0002\u2462\u2467\u0007", + "\u0197\u0002\u0002\u2463\u2464\u0005\u0482\u0242\u0002\u2464\u2465\t", + "6\u0002\u0002\u2465\u2467\u0003\u0002\u0002\u0002\u2466\u245f\u0003", + "\u0002\u0002\u0002\u2466\u2461\u0003\u0002\u0002\u0002\u2466\u2463\u0003", + "\u0002\u0002\u0002\u2467\u04e1\u0003\u0002\u0002\u0002\u2468\u246f\u0007", + "\u00c9\u0002\u0002\u2469\u246a\u0007\u01ab\u0002\u0002\u246a\u2470\u0007", + "\u0197\u0002\u0002\u246b\u2470\u0007D\u0002\u0002\u246c\u2470\u0007", + "\u01cc\u0002\u0002\u246d\u246e\u0007\u0106\u0002\u0002\u246e\u2470\u0007", + "\u01db\u0002\u0002\u246f\u2469\u0003\u0002\u0002\u0002\u246f\u246b\u0003", + "\u0002\u0002\u0002\u246f\u246c\u0003\u0002\u0002\u0002\u246f\u246d\u0003", + "\u0002\u0002\u0002\u2470\u2473\u0003\u0002\u0002\u0002\u2471\u2473\u0003", + "\u0002\u0002\u0002\u2472\u2468\u0003\u0002\u0002\u0002\u2472\u2471\u0003", + "\u0002\u0002\u0002\u2473\u04e3\u0003\u0002\u0002\u0002\u2474\u2475\u0007", + "\u0197\u0002\u0002\u2475\u2477\u0007\u0004\u0002\u0002\u2476\u2478\u0005", + "\u04f6\u027c\u0002\u2477\u2476\u0003\u0002\u0002\u0002\u2477\u2478\u0003", + "\u0002\u0002\u0002\u2478\u2479\u0003\u0002\u0002\u0002\u2479\u2481\u0007", + "\u0005\u0002\u0002\u247a\u247b\u0007\u0004\u0002\u0002\u247b\u247c\u0005", + "\u04f6\u027c\u0002\u247c\u247d\u0007\b\u0002\u0002\u247d\u247e\u0005", + "\u0482\u0242\u0002\u247e\u247f\u0007\u0005\u0002\u0002\u247f\u2481\u0003", + "\u0002\u0002\u0002\u2480\u2474\u0003\u0002\u0002\u0002\u2480\u247a\u0003", + "\u0002\u0002\u0002\u2481\u04e5\u0003\u0002\u0002\u0002\u2482\u2483\u0007", + "\u0197\u0002\u0002\u2483\u2485\u0007\u0004\u0002\u0002\u2484\u2486\u0005", + "\u04f6\u027c\u0002\u2485\u2484\u0003\u0002\u0002\u0002\u2485\u2486\u0003", + "\u0002\u0002\u0002\u2486\u2487\u0003\u0002\u0002\u0002\u2487\u2488\u0007", + "\u0005\u0002\u0002\u2488\u04e7\u0003\u0002\u0002\u0002\u2489\u248a\u0007", + "\u0004\u0002\u0002\u248a\u248b\u0005\u04f6\u027c\u0002\u248b\u248c\u0007", + "\b\u0002\u0002\u248c\u248d\u0005\u0482\u0242\u0002\u248d\u248e\u0007", + "\u0005\u0002\u0002\u248e\u04e9\u0003\u0002\u0002\u0002\u248f\u2490\t", + "7\u0002\u0002\u2490\u04eb\u0003\u0002\u0002\u0002\u2491\u2494\u0007", + "\u001f\u0002\u0002\u2492\u2494\u0005\u04ee\u0278\u0002\u2493\u2491\u0003", + "\u0002\u0002\u0002\u2493\u2492\u0003\u0002\u0002\u0002\u2494\u04ed\u0003", + "\u0002\u0002\u0002\u2495\u2496\t8\u0002\u0002\u2496\u04ef\u0003\u0002", + "\u0002\u0002\u2497\u249e\u0007\u001f\u0002\u0002\u2498\u2499\u0007\u010f", + "\u0002\u0002\u2499\u249a\u0007\u0004\u0002\u0002\u249a\u249b\u0005\u02ae", + "\u0158\u0002\u249b\u249c\u0007\u0005\u0002\u0002\u249c\u249e\u0003\u0002", + "\u0002\u0002\u249d\u2497\u0003\u0002\u0002\u0002\u249d\u2498\u0003\u0002", + "\u0002\u0002\u249e\u04f1\u0003\u0002\u0002\u0002\u249f\u24a6\u0005\u04ec", + "\u0277\u0002\u24a0\u24a1\u0007\u010f\u0002\u0002\u24a1\u24a2\u0007\u0004", + "\u0002\u0002\u24a2\u24a3\u0005\u02ae\u0158\u0002\u24a3\u24a4\u0007\u0005", + "\u0002\u0002\u24a4\u24a6\u0003\u0002\u0002\u0002\u24a5\u249f\u0003\u0002", + "\u0002\u0002\u24a5\u24a0\u0003\u0002\u0002\u0002\u24a6\u04f3\u0003\u0002", + "\u0002\u0002\u24a7\u24b4\u0005\u04ec\u0277\u0002\u24a8\u24a9\u0007\u010f", + "\u0002\u0002\u24a9\u24aa\u0007\u0004\u0002\u0002\u24aa\u24ab\u0005\u02ae", + "\u0158\u0002\u24ab\u24ac\u0007\u0005\u0002\u0002\u24ac\u24b4\u0003\u0002", + "\u0002\u0002\u24ad\u24b4\u0007z\u0002\u0002\u24ae\u24af\u0007O\u0002", + "\u0002\u24af\u24b4\u0007z\u0002\u0002\u24b0\u24b4\u0007t\u0002\u0002", + "\u24b1\u24b2\u0007O\u0002\u0002\u24b2\u24b4\u0007t\u0002\u0002\u24b3", + "\u24a7\u0003\u0002\u0002\u0002\u24b3\u24a8\u0003\u0002\u0002\u0002\u24b3", + "\u24ad\u0003\u0002\u0002\u0002\u24b3\u24ae\u0003\u0002\u0002\u0002\u24b3", + "\u24b0\u0003\u0002\u0002\u0002\u24b3\u24b1\u0003\u0002\u0002\u0002\u24b4", + "\u04f5\u0003\u0002\u0002\u0002\u24b5\u24ba\u0005\u0482\u0242\u0002\u24b6", + "\u24b7\u0007\b\u0002\u0002\u24b7\u24b9\u0005\u0482\u0242\u0002\u24b8", + "\u24b6\u0003\u0002\u0002\u0002\u24b9\u24bc\u0003\u0002\u0002\u0002\u24ba", + "\u24b8\u0003\u0002\u0002\u0002\u24ba\u24bb\u0003\u0002\u0002\u0002\u24bb", + "\u04f7\u0003\u0002\u0002\u0002\u24bc\u24ba\u0003\u0002\u0002\u0002\u24bd", + "\u24c2\u0005\u04fa\u027e\u0002\u24be\u24bf\u0007\b\u0002\u0002\u24bf", + "\u24c1\u0005\u04fa\u027e\u0002\u24c0\u24be\u0003\u0002\u0002\u0002\u24c1", + "\u24c4\u0003\u0002\u0002\u0002\u24c2\u24c0\u0003\u0002\u0002\u0002\u24c2", + "\u24c3\u0003\u0002\u0002\u0002\u24c3\u04f9\u0003\u0002\u0002\u0002\u24c4", + "\u24c2\u0003\u0002\u0002\u0002\u24c5\u24cb\u0005\u0482\u0242\u0002\u24c6", + "\u24c7\u0005\u027e\u0140\u0002\u24c7\u24c8\t9\u0002\u0002\u24c8\u24c9", + "\u0005\u0482\u0242\u0002\u24c9\u24cb\u0003\u0002\u0002\u0002\u24ca\u24c5", + "\u0003\u0002\u0002\u0002\u24ca\u24c6\u0003\u0002\u0002\u0002\u24cb\u04fb", + "\u0003\u0002\u0002\u0002\u24cc\u24d1\u0005\u0456\u022c\u0002\u24cd\u24ce", + "\u0007\b\u0002\u0002\u24ce\u24d0\u0005\u0456\u022c\u0002\u24cf\u24cd", + "\u0003\u0002\u0002\u0002\u24d0\u24d3\u0003\u0002\u0002\u0002\u24d1\u24cf", + "\u0003\u0002\u0002\u0002\u24d1\u24d2\u0003\u0002\u0002\u0002\u24d2\u04fd", + "\u0003\u0002\u0002\u0002\u24d3\u24d1\u0003\u0002\u0002\u0002\u24d4\u24d7", + "\u0007\u0006\u0002\u0002\u24d5\u24d8\u0005\u04f6\u027c\u0002\u24d6\u24d8", + "\u0005\u0500\u0281\u0002\u24d7\u24d5\u0003\u0002\u0002\u0002\u24d7\u24d6", + "\u0003\u0002\u0002\u0002\u24d7\u24d8\u0003\u0002\u0002\u0002\u24d8\u24d9", + "\u0003\u0002\u0002\u0002\u24d9\u24da\u0007\u0007\u0002\u0002\u24da\u04ff", + "\u0003\u0002\u0002\u0002\u24db\u24e0\u0005\u04fe\u0280\u0002\u24dc\u24dd", + "\u0007\b\u0002\u0002\u24dd\u24df\u0005\u04fe\u0280\u0002\u24de\u24dc", + "\u0003\u0002\u0002\u0002\u24df\u24e2\u0003\u0002\u0002\u0002\u24e0\u24de", + "\u0003\u0002\u0002\u0002\u24e0\u24e1\u0003\u0002\u0002\u0002\u24e1\u0501", + "\u0003\u0002\u0002\u0002\u24e2\u24e0\u0003\u0002\u0002\u0002\u24e3\u24e4", + "\u0005\u0504\u0283\u0002\u24e4\u24e5\u0007B\u0002\u0002\u24e5\u24e6", + "\u0005\u0482\u0242\u0002\u24e6\u24e9\u0003\u0002\u0002\u0002\u24e7\u24e9", + "\u0003\u0002\u0002\u0002\u24e8\u24e3\u0003\u0002\u0002\u0002\u24e8\u24e7", + "\u0003\u0002\u0002\u0002\u24e9\u0503\u0003\u0002\u0002\u0002\u24ea\u24f3", + "\u0005\u055a\u02ae\u0002\u24eb\u24f3\u0007\u0179\u0002\u0002\u24ec\u24f3", + "\u0007\u0101\u0002\u0002\u24ed\u24f3\u0007\u00b2\u0002\u0002\u24ee\u24f3", + "\u0007\u00dc\u0002\u0002\u24ef\u24f3\u0007\u00fe\u0002\u0002\u24f0\u24f3", + "\u0007\u013f\u0002\u0002\u24f1\u24f3\u0005\u0544\u02a3\u0002\u24f2\u24ea", + "\u0003\u0002\u0002\u0002\u24f2\u24eb\u0003\u0002\u0002\u0002\u24f2\u24ec", + "\u0003\u0002\u0002\u0002\u24f2\u24ed\u0003\u0002\u0002\u0002\u24f2\u24ee", + "\u0003\u0002\u0002\u0002\u24f2\u24ef\u0003\u0002\u0002\u0002\u24f2\u24f0", + "\u0003\u0002\u0002\u0002\u24f2\u24f1\u0003\u0002\u0002\u0002\u24f3\u0505", + "\u0003\u0002\u0002\u0002\u24f4\u24f5\t:\u0002\u0002\u24f5\u0507\u0003", + "\u0002\u0002\u0002\u24f6\u24f7\u0005\u0482\u0242\u0002\u24f7\u24f8\u0007", + "V\u0002\u0002\u24f8\u24f9\u0005\u0482\u0242\u0002\u24f9\u24fa\u0007", + "B\u0002\u0002\u24fa\u24fd\u0005\u0482\u0242\u0002\u24fb\u24fc\u0007", + "@\u0002\u0002\u24fc\u24fe\u0005\u0482\u0242\u0002\u24fd\u24fb\u0003", + "\u0002\u0002\u0002\u24fd\u24fe\u0003\u0002\u0002\u0002\u24fe\u0509\u0003", + "\u0002\u0002\u0002\u24ff\u2500\u0005\u04aa\u0256\u0002\u2500\u2501\u0007", + "F\u0002\u0002\u2501\u2502\u0005\u04aa\u0256\u0002\u2502\u2505\u0003", + "\u0002\u0002\u0002\u2503\u2505\u0003\u0002\u0002\u0002\u2504\u24ff\u0003", + "\u0002\u0002\u0002\u2504\u2503\u0003\u0002\u0002\u0002\u2505\u050b\u0003", + "\u0002\u0002\u0002\u2506\u2507\u0005\u0482\u0242\u0002\u2507\u2508\u0007", + "B\u0002\u0002\u2508\u2509\u0005\u0482\u0242\u0002\u2509\u250a\u0007", + "@\u0002\u0002\u250a\u250b\u0005\u0482\u0242\u0002\u250b\u2523\u0003", + "\u0002\u0002\u0002\u250c\u250d\u0005\u0482\u0242\u0002\u250d\u250e\u0007", + "@\u0002\u0002\u250e\u250f\u0005\u0482\u0242\u0002\u250f\u2510\u0007", + "B\u0002\u0002\u2510\u2511\u0005\u0482\u0242\u0002\u2511\u2523\u0003", + "\u0002\u0002\u0002\u2512\u2513\u0005\u0482\u0242\u0002\u2513\u2514\u0007", + "B\u0002\u0002\u2514\u2515\u0005\u0482\u0242\u0002\u2515\u2523\u0003", + "\u0002\u0002\u0002\u2516\u2517\u0005\u0482\u0242\u0002\u2517\u2518\u0007", + "@\u0002\u0002\u2518\u2519\u0005\u0482\u0242\u0002\u2519\u2523\u0003", + "\u0002\u0002\u0002\u251a\u251b\u0005\u0482\u0242\u0002\u251b\u251c\u0007", + "\u0081\u0002\u0002\u251c\u251d\u0005\u0482\u0242\u0002\u251d\u251e\u0007", + "\u00c7\u0002\u0002\u251e\u251f\u0005\u0482\u0242\u0002\u251f\u2523\u0003", + "\u0002\u0002\u0002\u2520\u2523\u0005\u04f6\u027c\u0002\u2521\u2523\u0003", + "\u0002\u0002\u0002\u2522\u2506\u0003\u0002\u0002\u0002\u2522\u250c\u0003", + "\u0002\u0002\u0002\u2522\u2512\u0003\u0002\u0002\u0002\u2522\u2516\u0003", + "\u0002\u0002\u0002\u2522\u251a\u0003\u0002\u0002\u0002\u2522\u2520\u0003", + "\u0002\u0002\u0002\u2522\u2521\u0003\u0002\u0002\u0002\u2523\u050d\u0003", + "\u0002\u0002\u0002\u2524\u2525\u0005\u0482\u0242\u0002\u2525\u2526\u0007", + "B\u0002\u0002\u2526\u2527\u0005\u04f6\u027c\u0002\u2527\u252c\u0003", + "\u0002\u0002\u0002\u2528\u2529\u0007B\u0002\u0002\u2529\u252c\u0005", + "\u04f6\u027c\u0002\u252a\u252c\u0005\u04f6\u027c\u0002\u252b\u2524\u0003", + "\u0002\u0002\u0002\u252b\u2528\u0003\u0002\u0002\u0002\u252b\u252a\u0003", + "\u0002\u0002\u0002\u252c\u050f\u0003\u0002\u0002\u0002\u252d\u2533\u0005", + "\u03bc\u01df\u0002\u252e\u252f\u0007\u0004\u0002\u0002\u252f\u2530\u0005", + "\u04f6\u027c\u0002\u2530\u2531\u0007\u0005\u0002\u0002\u2531\u2533\u0003", + "\u0002\u0002\u0002\u2532\u252d\u0003\u0002\u0002\u0002\u2532\u252e\u0003", + "\u0002\u0002\u0002\u2533\u0511\u0003\u0002\u0002\u0002\u2534\u2535\u0007", + "*\u0002\u0002\u2535\u2536\u0005\u051a\u028e\u0002\u2536\u2537\u0005", + "\u0514\u028b\u0002\u2537\u2538\u0005\u0518\u028d\u0002\u2538\u2539\u0007", + "\u01bf\u0002\u0002\u2539\u0513\u0003\u0002\u0002\u0002\u253a\u253c\u0005", + "\u0516\u028c\u0002\u253b\u253a\u0003\u0002\u0002\u0002\u253c\u253d\u0003", + "\u0002\u0002\u0002\u253d\u253b\u0003\u0002\u0002\u0002\u253d\u253e\u0003", + "\u0002\u0002\u0002\u253e\u0515\u0003\u0002\u0002\u0002\u253f\u2540\u0007", + "h\u0002\u0002\u2540\u2541\u0005\u0482\u0242\u0002\u2541\u2542\u0007", + "_\u0002\u0002\u2542\u2543\u0005\u0482\u0242\u0002\u2543\u0517\u0003", + "\u0002\u0002\u0002\u2544\u2545\u0007<\u0002\u0002\u2545\u2548\u0005", + "\u0482\u0242\u0002\u2546\u2548\u0003\u0002\u0002\u0002\u2547\u2544\u0003", + "\u0002\u0002\u0002\u2547\u2546\u0003\u0002\u0002\u0002\u2548\u0519\u0003", + "\u0002\u0002\u0002\u2549\u254c\u0005\u0482\u0242\u0002\u254a\u254c\u0003", + "\u0002\u0002\u0002\u254b\u2549\u0003\u0002\u0002\u0002\u254b\u254a\u0003", + "\u0002\u0002\u0002\u254c\u051b\u0003\u0002\u0002\u0002\u254d\u254f\u0005", + "\u0552\u02aa\u0002\u254e\u2550\u0005\u0522\u0292\u0002\u254f\u254e\u0003", + "\u0002\u0002\u0002\u254f\u2550\u0003\u0002\u0002\u0002\u2550\u051d\u0003", + "\u0002\u0002\u0002\u2551\u2554\u0007\r\u0002\u0002\u2552\u2555\u0005", + "\u0534\u029b\u0002\u2553\u2555\u0007\u000b\u0002\u0002\u2554\u2552\u0003", + "\u0002\u0002\u0002\u2554\u2553\u0003\u0002\u0002\u0002\u2555\u2561\u0003", + "\u0002\u0002\u0002\u2556\u255c\u0007\u0006\u0002\u0002\u2557\u255d\u0005", + "\u0482\u0242\u0002\u2558\u2559\u0005\u0520\u0291\u0002\u2559\u255a\u0007", + "\n\u0002\u0002\u255a\u255b\u0005\u0520\u0291\u0002\u255b\u255d\u0003", + "\u0002\u0002\u0002\u255c\u2557\u0003\u0002\u0002\u0002\u255c\u2558\u0003", + "\u0002\u0002\u0002\u255d\u255e\u0003\u0002\u0002\u0002\u255e\u255f\u0007", + "\u0007\u0002\u0002\u255f\u2561\u0003\u0002\u0002\u0002\u2560\u2551\u0003", + "\u0002\u0002\u0002\u2560\u2556\u0003\u0002\u0002\u0002\u2561\u051f\u0003", + "\u0002\u0002\u0002\u2562\u2565\u0005\u0482\u0242\u0002\u2563\u2565\u0003", + "\u0002\u0002\u0002\u2564\u2562\u0003\u0002\u0002\u0002\u2564\u2563\u0003", + "\u0002\u0002\u0002\u2565\u0521\u0003\u0002\u0002\u0002\u2566\u2568\u0005", + "\u051e\u0290\u0002\u2567\u2566\u0003\u0002\u0002\u0002\u2568\u2569\u0003", + "\u0002\u0002\u0002\u2569\u2567\u0003\u0002\u0002\u0002\u2569\u256a\u0003", + "\u0002\u0002\u0002\u256a\u0523\u0003\u0002\u0002\u0002\u256b\u256d\u0005", + "\u051e\u0290\u0002\u256c\u256b\u0003\u0002\u0002\u0002\u256d\u2570\u0003", + "\u0002\u0002\u0002\u256e\u256c\u0003\u0002\u0002\u0002\u256e\u256f\u0003", + "\u0002\u0002\u0002\u256f\u0525\u0003\u0002\u0002\u0002\u2570\u256e\u0003", + "\u0002\u0002\u0002\u2571\u2574\u0005\u0528\u0295\u0002\u2572\u2574\u0003", + "\u0002\u0002\u0002\u2573\u2571\u0003\u0002\u0002\u0002\u2573\u2572\u0003", + "\u0002\u0002\u0002\u2574\u0527\u0003\u0002\u0002\u0002\u2575\u257a\u0005", + "\u052a\u0296\u0002\u2576\u2577\u0007\b\u0002\u0002\u2577\u2579\u0005", + "\u052a\u0296\u0002\u2578\u2576\u0003\u0002\u0002\u0002\u2579\u257c\u0003", + "\u0002\u0002\u0002\u257a\u2578\u0003\u0002\u0002\u0002\u257a\u257b\u0003", + "\u0002\u0002\u0002\u257b\u0529\u0003\u0002\u0002\u0002\u257c\u257a\u0003", + "\u0002\u0002\u0002\u257d\u2582\u0005\u0482\u0242\u0002\u257e\u257f\u0007", + "&\u0002\u0002\u257f\u2583\u0005\u0558\u02ad\u0002\u2580\u2583\u0005", + "\u055a\u02ae\u0002\u2581\u2583\u0003\u0002\u0002\u0002\u2582\u257e\u0003", + "\u0002\u0002\u0002\u2582\u2580\u0003\u0002\u0002\u0002\u2582\u2581\u0003", + "\u0002\u0002\u0002\u2583\u2586\u0003\u0002\u0002\u0002\u2584\u2586\u0007", + "\u000b\u0002\u0002\u2585\u257d\u0003\u0002\u0002\u0002\u2585\u2584\u0003", + "\u0002\u0002\u0002\u2586\u052b\u0003\u0002\u0002\u0002\u2587\u258c\u0005", + "\u052e\u0298\u0002\u2588\u2589\u0007\b\u0002\u0002\u2589\u258b\u0005", + "\u052e\u0298\u0002\u258a\u2588\u0003\u0002\u0002\u0002\u258b\u258e\u0003", + "\u0002\u0002\u0002\u258c\u258a\u0003\u0002\u0002\u0002\u258c\u258d\u0003", + "\u0002\u0002\u0002\u258d\u052d\u0003\u0002\u0002\u0002\u258e\u258c\u0003", + "\u0002\u0002\u0002\u258f\u2591\u0005\u0552\u02aa\u0002\u2590\u2592\u0005", + "\u0522\u0292\u0002\u2591\u2590\u0003\u0002\u0002\u0002\u2591\u2592\u0003", + "\u0002\u0002\u0002\u2592\u052f\u0003\u0002\u0002\u0002\u2593\u2598\u0005", + "\u0532\u029a\u0002\u2594\u2595\u0007\b\u0002\u0002\u2595\u2597\u0005", + "\u0532\u029a\u0002\u2596\u2594\u0003\u0002\u0002\u0002\u2597\u259a\u0003", + "\u0002\u0002\u0002\u2598\u2596\u0003\u0002\u0002\u0002\u2598\u2599\u0003", + "\u0002\u0002\u0002\u2599\u0531\u0003\u0002\u0002\u0002\u259a\u2598\u0003", + "\u0002\u0002\u0002\u259b\u259c\u0005\u0552\u02aa\u0002\u259c\u0533\u0003", + "\u0002\u0002\u0002\u259d\u259e\u0005\u0558\u02ad\u0002\u259e\u0535\u0003", + "\u0002\u0002\u0002\u259f\u25a0\u0005\u0544\u02a3\u0002\u25a0\u0537\u0003", + "\u0002\u0002\u0002\u25a1\u25a6\u0005\u0554\u02ab\u0002\u25a2\u25a3\u0005", + "\u0552\u02aa\u0002\u25a3\u25a4\u0005\u0522\u0292\u0002\u25a4\u25a6\u0003", + "\u0002\u0002\u0002\u25a5\u25a1\u0003\u0002\u0002\u0002\u25a5\u25a2\u0003", + "\u0002\u0002\u0002\u25a6\u0539\u0003\u0002\u0002\u0002\u25a7\u25c8\u0005", + "\u0542\u02a2\u0002\u25a8\u25c8\u0005\u0540\u02a1\u0002\u25a9\u25c8\u0005", + "\u0544\u02a3\u0002\u25aa\u25c8\u0005\u053e\u02a0\u0002\u25ab\u25c8\u0005", + "\u053c\u029f\u0002\u25ac\u25b4\u0005\u0538\u029d\u0002\u25ad\u25b5\u0005", + "\u0544\u02a3\u0002\u25ae\u25af\u0007\u0004\u0002\u0002\u25af\u25b0\u0005", + "\u04f8\u027d\u0002\u25b0\u25b1\u0005\u03e0\u01f1\u0002\u25b1\u25b2\u0007", + "\u0005\u0002\u0002\u25b2\u25b3\u0005\u0544\u02a3\u0002\u25b3\u25b5\u0003", + "\u0002\u0002\u0002\u25b4\u25ad\u0003\u0002\u0002\u0002\u25b4\u25ae\u0003", + "\u0002\u0002\u0002\u25b5\u25c8\u0003\u0002\u0002\u0002\u25b6\u25b7\u0005", + "\u045c\u022f\u0002\u25b7\u25b8\u0005\u0544\u02a3\u0002\u25b8\u25c8\u0003", + "\u0002\u0002\u0002\u25b9\u25c2\u0005\u0478\u023d\u0002\u25ba\u25bb\u0005", + "\u0544\u02a3\u0002\u25bb\u25bc\u0005\u047c\u023f\u0002\u25bc\u25c3\u0003", + "\u0002\u0002\u0002\u25bd\u25be\u0007\u0004\u0002\u0002\u25be\u25bf\u0005", + "\u0542\u02a2\u0002\u25bf\u25c0\u0007\u0005\u0002\u0002\u25c0\u25c1\u0005", + "\u0544\u02a3\u0002\u25c1\u25c3\u0003\u0002\u0002\u0002\u25c2\u25ba\u0003", + "\u0002\u0002\u0002\u25c2\u25bd\u0003\u0002\u0002\u0002\u25c3\u25c8\u0003", + "\u0002\u0002\u0002\u25c4\u25c8\u0007b\u0002\u0002\u25c5\u25c8\u0007", + ">\u0002\u0002\u25c6\u25c8\u0007P\u0002\u0002\u25c7\u25a7\u0003\u0002", + "\u0002\u0002\u25c7\u25a8\u0003\u0002\u0002\u0002\u25c7\u25a9\u0003\u0002", + "\u0002\u0002\u25c7\u25aa\u0003\u0002\u0002\u0002\u25c7\u25ab\u0003\u0002", + "\u0002\u0002\u25c7\u25ac\u0003\u0002\u0002\u0002\u25c7\u25b6\u0003\u0002", + "\u0002\u0002\u25c7\u25b9\u0003\u0002\u0002\u0002\u25c7\u25c4\u0003\u0002", + "\u0002\u0002\u25c7\u25c5\u0003\u0002\u0002\u0002\u25c7\u25c6\u0003\u0002", + "\u0002\u0002\u25c8\u053b\u0003\u0002\u0002\u0002\u25c9\u25ca\u0007\u0214", + "\u0002\u0002\u25ca\u053d\u0003\u0002\u0002\u0002\u25cb\u25cc\u0007\u0210", + "\u0002\u0002\u25cc\u053f\u0003\u0002\u0002\u0002\u25cd\u25ce\u0007\u021a", + "\u0002\u0002\u25ce\u0541\u0003\u0002\u0002\u0002\u25cf\u25d0\u0007\u0218", + "\u0002\u0002\u25d0\u0543\u0003\u0002\u0002\u0002\u25d1\u25d2\u0005\u0546", + "\u02a4\u0002\u25d2\u25d3\u0005\u0548\u02a5\u0002\u25d3\u0545\u0003\u0002", + "\u0002\u0002\u25d4\u25e0\u0007\u020b\u0002\u0002\u25d5\u25e0\u0007\u020d", + "\u0002\u0002\u25d6\u25da\u0007\u020f\u0002\u0002\u25d7\u25d9\u0007\u022b", + "\u0002\u0002\u25d8\u25d7\u0003\u0002\u0002\u0002\u25d9\u25dc\u0003\u0002", + "\u0002\u0002\u25da\u25d8\u0003\u0002\u0002\u0002\u25da\u25db\u0003\u0002", + "\u0002\u0002\u25db\u25dd\u0003\u0002\u0002\u0002\u25dc\u25da\u0003\u0002", + "\u0002\u0002\u25dd\u25e0\u0007\u022c\u0002\u0002\u25de\u25e0\u0007\u0225", + "\u0002\u0002\u25df\u25d4\u0003\u0002\u0002\u0002\u25df\u25d5\u0003\u0002", + "\u0002\u0002\u25df\u25d6\u0003\u0002\u0002\u0002\u25df\u25de\u0003\u0002", + "\u0002\u0002\u25e0\u0547\u0003\u0002\u0002\u0002\u25e1\u25e2\u0007\u01e0", + "\u0002\u0002\u25e2\u25e5\u0005\u0546\u02a4\u0002\u25e3\u25e5\u0003\u0002", + "\u0002\u0002\u25e4\u25e1\u0003\u0002\u0002\u0002\u25e4\u25e3\u0003\u0002", + "\u0002\u0002\u25e5\u0549\u0003\u0002\u0002\u0002\u25e6\u25ec\u0005\u0542", + "\u02a2\u0002\u25e7\u25e8\u0007\u000e\u0002\u0002\u25e8\u25ec\u0005\u0542", + "\u02a2\u0002\u25e9\u25ea\u0007\u000f\u0002\u0002\u25ea\u25ec\u0005\u0542", + "\u02a2\u0002\u25eb\u25e6\u0003\u0002\u0002\u0002\u25eb\u25e7\u0003\u0002", + "\u0002\u0002\u25eb\u25e9\u0003\u0002\u0002\u0002\u25ec\u054b\u0003\u0002", + "\u0002\u0002\u25ed\u25ee\u0005\u054e\u02a8\u0002\u25ee\u054d\u0003\u0002", + "\u0002\u0002\u25ef\u25f3\u0005\u0556\u02ac\u0002\u25f0\u25f3\u00076", + "\u0002\u0002\u25f1\u25f3\u0007[\u0002\u0002\u25f2\u25ef\u0003\u0002", + "\u0002\u0002\u25f2\u25f0\u0003\u0002\u0002\u0002\u25f2\u25f1\u0003\u0002", + "\u0002\u0002\u25f3\u054f\u0003\u0002\u0002\u0002\u25f4\u25f9\u0005\u054e", + "\u02a8\u0002\u25f5\u25f6\u0007\b\u0002\u0002\u25f6\u25f8\u0005\u054e", + "\u02a8\u0002\u25f7\u25f5\u0003\u0002\u0002\u0002\u25f8\u25fb\u0003\u0002", + "\u0002\u0002\u25f9\u25f7\u0003\u0002\u0002\u0002\u25f9\u25fa\u0003\u0002", + "\u0002\u0002\u25fa\u0551\u0003\u0002\u0002\u0002\u25fb\u25f9\u0003\u0002", + "\u0002\u0002\u25fc\u2601\u0005\u055a\u02ae\u0002\u25fd\u2601\u0005\u055e", + "\u02b0\u0002\u25fe\u2601\u0005\u0560\u02b1\u0002\u25ff\u2601\u0005\u063a", + "\u031e\u0002\u2600\u25fc\u0003\u0002\u0002\u0002\u2600\u25fd\u0003\u0002", + "\u0002\u0002\u2600\u25fe\u0003\u0002\u0002\u0002\u2600\u25ff\u0003\u0002", + "\u0002\u0002\u2601\u0553\u0003\u0002\u0002\u0002\u2602\u2607\u0005\u055a", + "\u02ae\u0002\u2603\u2607\u0005\u055e\u02b0\u0002\u2604\u2607\u0005\u063a", + "\u031e\u0002\u2605\u2607\u0005\u0562\u02b2\u0002\u2606\u2602\u0003\u0002", + "\u0002\u0002\u2606\u2603\u0003\u0002\u0002\u0002\u2606\u2604\u0003\u0002", + "\u0002\u0002\u2606\u2605\u0003\u0002\u0002\u0002\u2607\u0555\u0003\u0002", + "\u0002\u0002\u2608\u260d\u0005\u055a\u02ae\u0002\u2609\u260d\u0005\u055e", + "\u02b0\u0002\u260a\u260d\u0005\u0560\u02b1\u0002\u260b\u260d\u0005\u0562", + "\u02b2\u0002\u260c\u2608\u0003\u0002\u0002\u0002\u260c\u2609\u0003\u0002", + "\u0002\u0002\u260c\u260a\u0003\u0002\u0002\u0002\u260c\u260b\u0003\u0002", + "\u0002\u0002\u260d\u0557\u0003\u0002\u0002\u0002\u260e\u2615\u0005\u055a", + "\u02ae\u0002\u260f\u2615\u0005\u063a\u031e\u0002\u2610\u2615\u0005\u055e", + "\u02b0\u0002\u2611\u2615\u0005\u0560\u02b1\u0002\u2612\u2615\u0005\u0562", + "\u02b2\u0002\u2613\u2615\u0005\u0564\u02b3\u0002\u2614\u260e\u0003\u0002", + "\u0002\u0002\u2614\u260f\u0003\u0002\u0002\u0002\u2614\u2610\u0003\u0002", + "\u0002\u0002\u2614\u2611\u0003\u0002\u0002\u0002\u2614\u2612\u0003\u0002", + "\u0002\u0002\u2614\u2613\u0003\u0002\u0002\u0002\u2615\u0559\u0003\u0002", + "\u0002\u0002\u2616\u2617\u0007\u0202\u0002\u0002\u2617\u261e\u0005\u0548", + "\u02a5\u0002\u2618\u261e\u0007\u0203\u0002\u0002\u2619\u261e\u0007\u0207", + "\u0002\u0002\u261a\u261e\u0005\u04ae\u0258\u0002\u261b\u261e\u0005\u055c", + "\u02af\u0002\u261c\u261e\u0005\u063a\u031e\u0002\u261d\u2616\u0003\u0002", + "\u0002\u0002\u261d\u2618\u0003\u0002\u0002\u0002\u261d\u2619\u0003\u0002", + "\u0002\u0002\u261d\u261a\u0003\u0002\u0002\u0002\u261d\u261b\u0003\u0002", + "\u0002\u0002\u261d\u261c\u0003\u0002\u0002\u0002\u261e\u055b\u0003\u0002", + "\u0002\u0002\u261f\u2620\u0007\u021c\u0002\u0002\u2620\u055d\u0003\u0002", + "\u0002\u0002\u2621\u2622\t;\u0002\u0002\u2622\u055f\u0003\u0002\u0002", + "\u0002\u2623\u2657\u0007\u017c\u0002\u0002\u2624\u2657\u0007\u017d\u0002", + "\u0002\u2625\u2657\u0005\u0466\u0234\u0002\u2626\u2657\u0007\u017f\u0002", + "\u0002\u2627\u2657\u0007\u0180\u0002\u0002\u2628\u2657\u0005\u046e\u0238", + "\u0002\u2629\u2657\u0007\u0182\u0002\u0002\u262a\u2657\u0007\u0183\u0002", + "\u0002\u262b\u2657\u0007\u0184\u0002\u0002\u262c\u2657\u0007\u0185\u0002", + "\u0002\u262d\u2657\u0007\u0186\u0002\u0002\u262e\u2657\u0007\u0187\u0002", + "\u0002\u262f\u2657\u0007\u0188\u0002\u0002\u2630\u2657\u0007\u01cf\u0002", + "\u0002\u2631\u2657\u0007\u0189\u0002\u0002\u2632\u2657\u0007\u018a\u0002", + "\u0002\u2633\u2657\u0007\u018b\u0002\u0002\u2634\u2657\u0007\u018c\u0002", + "\u0002\u2635\u2657\u0007\u018d\u0002\u0002\u2636\u2657\u0007\u018e\u0002", + "\u0002\u2637\u2657\u0007\u018f\u0002\u0002\u2638\u2657\u0007\u0190\u0002", + "\u0002\u2639\u2657\u0007\u01e2\u0002\u0002\u263a\u2657\u0007\u0191\u0002", + "\u0002\u263b\u2657\u0005\u0462\u0232\u0002\u263c\u2657\u0007\u01be\u0002", + "\u0002\u263d\u2657\u0007\u0193\u0002\u0002\u263e\u2657\u0007\u0194\u0002", + "\u0002\u263f\u2657\u0007\u0195\u0002\u0002\u2640\u2657\u0007\u0196\u0002", + "\u0002\u2641\u2657\u0007\u0197\u0002\u0002\u2642\u2657\u0007\u0198\u0002", + "\u0002\u2643\u2657\u0007\u0199\u0002\u0002\u2644\u2657\u0007\u019a\u0002", + "\u0002\u2645\u2657\u0007\u019b\u0002\u0002\u2646\u2657\u0007\u019c\u0002", + "\u0002\u2647\u2657\u0007\u019d\u0002\u0002\u2648\u2657\u0007\u019e\u0002", + "\u0002\u2649\u2657\u0007\u019f\u0002\u0002\u264a\u2657\u0007\u01a0\u0002", + "\u0002\u264b\u2657\u0007\u01a1\u0002\u0002\u264c\u2657\u0007\u01a2\u0002", + "\u0002\u264d\u2657\u0007\u01a3\u0002\u0002\u264e\u2657\u0007\u01a4\u0002", + "\u0002\u264f\u2657\u0007\u01a5\u0002\u0002\u2650\u2657\u0007\u01d5\u0002", + "\u0002\u2651\u2657\u0007\u01a6\u0002\u0002\u2652\u2657\u0007\u01a7\u0002", + "\u0002\u2653\u2657\u0007\u01a8\u0002\u0002\u2654\u2657\u0007\u01a9\u0002", + "\u0002\u2655\u2657\u0007\u01d3\u0002\u0002\u2656\u2623\u0003\u0002\u0002", + "\u0002\u2656\u2624\u0003\u0002\u0002\u0002\u2656\u2625\u0003\u0002\u0002", + "\u0002\u2656\u2626\u0003\u0002\u0002\u0002\u2656\u2627\u0003\u0002\u0002", + "\u0002\u2656\u2628\u0003\u0002\u0002\u0002\u2656\u2629\u0003\u0002\u0002", + "\u0002\u2656\u262a\u0003\u0002\u0002\u0002\u2656\u262b\u0003\u0002\u0002", + "\u0002\u2656\u262c\u0003\u0002\u0002\u0002\u2656\u262d\u0003\u0002\u0002", + "\u0002\u2656\u262e\u0003\u0002\u0002\u0002\u2656\u262f\u0003\u0002\u0002", + "\u0002\u2656\u2630\u0003\u0002\u0002\u0002\u2656\u2631\u0003\u0002\u0002", + "\u0002\u2656\u2632\u0003\u0002\u0002\u0002\u2656\u2633\u0003\u0002\u0002", + "\u0002\u2656\u2634\u0003\u0002\u0002\u0002\u2656\u2635\u0003\u0002\u0002", + "\u0002\u2656\u2636\u0003\u0002\u0002\u0002\u2656\u2637\u0003\u0002\u0002", + "\u0002\u2656\u2638\u0003\u0002\u0002\u0002\u2656\u2639\u0003\u0002\u0002", + "\u0002\u2656\u263a\u0003\u0002\u0002\u0002\u2656\u263b\u0003\u0002\u0002", + "\u0002\u2656\u263c\u0003\u0002\u0002\u0002\u2656\u263d\u0003\u0002\u0002", + "\u0002\u2656\u263e\u0003\u0002\u0002\u0002\u2656\u263f\u0003\u0002\u0002", + "\u0002\u2656\u2640\u0003\u0002\u0002\u0002\u2656\u2641\u0003\u0002\u0002", + "\u0002\u2656\u2642\u0003\u0002\u0002\u0002\u2656\u2643\u0003\u0002\u0002", + "\u0002\u2656\u2644\u0003\u0002\u0002\u0002\u2656\u2645\u0003\u0002\u0002", + "\u0002\u2656\u2646\u0003\u0002\u0002\u0002\u2656\u2647\u0003\u0002\u0002", + "\u0002\u2656\u2648\u0003\u0002\u0002\u0002\u2656\u2649\u0003\u0002\u0002", + "\u0002\u2656\u264a\u0003\u0002\u0002\u0002\u2656\u264b\u0003\u0002\u0002", + "\u0002\u2656\u264c\u0003\u0002\u0002\u0002\u2656\u264d\u0003\u0002\u0002", + "\u0002\u2656\u264e\u0003\u0002\u0002\u0002\u2656\u264f\u0003\u0002\u0002", + "\u0002\u2656\u2650\u0003\u0002\u0002\u0002\u2656\u2651\u0003\u0002\u0002", + "\u0002\u2656\u2652\u0003\u0002\u0002\u0002\u2656\u2653\u0003\u0002\u0002", + "\u0002\u2656\u2654\u0003\u0002\u0002\u0002\u2656\u2655\u0003\u0002\u0002", + "\u0002\u2657\u0561\u0003\u0002\u0002\u0002\u2658\u2659\t<\u0002\u0002", + "\u2659\u0563\u0003\u0002\u0002\u0002\u265a\u265b\t=\u0002\u0002\u265b", + "\u0565\u0003\u0002\u0002\u0002\u265c\u265d\u0005\u0568\u02b5\u0002\u265d", + "\u265e\u0005\u0572\u02ba\u0002\u265e\u265f\u0005\u0570\u02b9\u0002\u265f", + "\u0567\u0003\u0002\u0002\u0002\u2660\u2662\u0005\u056a\u02b6\u0002\u2661", + "\u2660\u0003\u0002\u0002\u0002\u2662\u2665\u0003\u0002\u0002\u0002\u2663", + "\u2661\u0003\u0002\u0002\u0002\u2663\u2664\u0003\u0002\u0002\u0002\u2664", + "\u0569\u0003\u0002\u0002\u0002\u2665\u2663\u0003\u0002\u0002\u0002\u2666", + "\u2667\u0005\u056c\u02b7\u0002\u2667\u2668\u0007\u0110\u0002\u0002\u2668", + "\u2669\u0007\u01e3\u0002\u0002\u2669\u267b\u0003\u0002\u0002\u0002\u266a", + "\u266b\u0005\u056c\u02b7\u0002\u266b\u266c\u0007\u01e4\u0002\u0002\u266c", + "\u266d\u0005\u056e\u02b8\u0002\u266d\u267b\u0003\u0002\u0002\u0002\u266e", + "\u266f\u0005\u056c\u02b7\u0002\u266f\u2670\u0007\u01e5\u0002\u0002\u2670", + "\u2671\u0007\u01e6\u0002\u0002\u2671\u267b\u0003\u0002\u0002\u0002\u2672", + "\u2673\u0005\u056c\u02b7\u0002\u2673\u2674\u0007\u01e5\u0002\u0002\u2674", + "\u2675\u0007\u01e7\u0002\u0002\u2675\u267b\u0003\u0002\u0002\u0002\u2676", + "\u2677\u0005\u056c\u02b7\u0002\u2677\u2678\u0007\u01e5\u0002\u0002\u2678", + "\u2679\u0007\u01e8\u0002\u0002\u2679\u267b\u0003\u0002\u0002\u0002\u267a", + "\u2666\u0003\u0002\u0002\u0002\u267a\u266a\u0003\u0002\u0002\u0002\u267a", + "\u266e\u0003\u0002\u0002\u0002\u267a\u2672\u0003\u0002\u0002\u0002\u267a", + "\u2676\u0003\u0002\u0002\u0002\u267b\u056b\u0003\u0002\u0002\u0002\u267c", + "\u267d\u0007\u001f\u0002\u0002\u267d\u056d\u0003\u0002\u0002\u0002\u267e", + "\u2683\u0005\u0544\u02a3\u0002\u267f\u2683\u0005\u0564\u02b3\u0002\u2680", + "\u2683\u0005\u063a\u031e\u0002\u2681\u2683\u0005\u055e\u02b0\u0002\u2682", + "\u267e\u0003\u0002\u0002\u0002\u2682\u267f\u0003\u0002\u0002\u0002\u2682", + "\u2680\u0003\u0002\u0002\u0002\u2682\u2681\u0003\u0002\u0002\u0002\u2683", + "\u056f\u0003\u0002\u0002\u0002\u2684\u2687\u0003\u0002\u0002\u0002\u2685", + "\u2687\u0007\t\u0002\u0002\u2686\u2684\u0003\u0002\u0002\u0002\u2686", + "\u2685\u0003\u0002\u0002\u0002\u2687\u0571\u0003\u0002\u0002\u0002\u2688", + "\u2689\u0005\u0574\u02bb\u0002\u2689\u268a\u0007\u0094\u0002\u0002\u268a", + "\u268b\u0005\u059e\u02d0\u0002\u268b\u268c\u0005\u0626\u0314\u0002\u268c", + "\u268d\u0007\u01bf\u0002\u0002\u268d\u268e\u0005\u0634\u031b\u0002\u268e", + "\u0573\u0003\u0002\u0002\u0002\u268f\u2694\u0005\u0630\u0319\u0002\u2690", + "\u2692\u0005\u0576\u02bc\u0002\u2691\u2693\u0005\u0578\u02bd\u0002\u2692", + "\u2691\u0003\u0002\u0002\u0002\u2692\u2693\u0003\u0002\u0002\u0002\u2693", + "\u2695\u0003\u0002\u0002\u0002\u2694\u2690\u0003\u0002\u0002\u0002\u2694", + "\u2695\u0003\u0002\u0002\u0002\u2695\u0575\u0003\u0002\u0002\u0002\u2696", + "\u2697\u0007\u00b4\u0002\u0002\u2697\u0577\u0003\u0002\u0002\u0002\u2698", + "\u269a\u0005\u057c\u02bf\u0002\u2699\u2698\u0003\u0002\u0002\u0002\u269a", + "\u269b\u0003\u0002\u0002\u0002\u269b\u2699\u0003\u0002\u0002\u0002\u269b", + "\u269c\u0003\u0002\u0002\u0002\u269c\u0579\u0003\u0002\u0002\u0002\u269d", + "\u269e\u0007\u0014\u0002\u0002\u269e\u269f\u0005\u0638\u031d\u0002\u269f", + "\u26a0\u0007\u0015\u0002\u0002\u26a0\u057b\u0003\u0002\u0002\u0002\u26a1", + "\u26a5\u0005\u057e\u02c0\u0002\u26a2\u26a5\u0007\u00b4\u0002\u0002\u26a3", + "\u26a5\u0005\u057a\u02be\u0002\u26a4\u26a1\u0003\u0002\u0002\u0002\u26a4", + "\u26a2\u0003\u0002\u0002\u0002\u26a4\u26a3\u0003\u0002\u0002\u0002\u26a5", + "\u057d\u0003\u0002\u0002\u0002\u26a6\u26b6\u0005\u058e\u02c8\u0002\u26a7", + "\u26a8\u0007\u01e9\u0002\u0002\u26a8\u26a9\u0007@\u0002\u0002\u26a9", + "\u26b7\u0005\u058c\u02c7\u0002\u26aa\u26ab\u0005\u0590\u02c9\u0002\u26ab", + "\u26ac\u0005\u0592\u02ca\u0002\u26ac\u26ad\u0005\u0594\u02cb\u0002\u26ad", + "\u26ae\u0005\u0596\u02cc\u0002\u26ae\u26af\u0005\u0598\u02cd\u0002\u26af", + "\u26b7\u0003\u0002\u0002\u0002\u26b0\u26b1\u0005\u0580\u02c1\u0002\u26b1", + "\u26b2\u0007\u00ae\u0002\u0002\u26b2\u26b3\u0005\u0584\u02c3\u0002\u26b3", + "\u26b4\u0005\u058a\u02c6\u0002\u26b4\u26b5\u0005\u0582\u02c2\u0002\u26b5", + "\u26b7\u0003\u0002\u0002\u0002\u26b6\u26a7\u0003\u0002\u0002\u0002\u26b6", + "\u26aa\u0003\u0002\u0002\u0002\u26b6\u26b0\u0003\u0002\u0002\u0002\u26b7", + "\u26b8\u0003\u0002\u0002\u0002\u26b8\u26b9\u0007\t\u0002\u0002\u26b9", + "\u057f\u0003\u0002\u0002\u0002\u26ba\u26bf\u0003\u0002\u0002\u0002\u26bb", + "\u26bc\u0007\u0106\u0002\u0002\u26bc\u26bf\u0007\u013d\u0002\u0002\u26bd", + "\u26bf\u0007\u013d\u0002\u0002\u26be\u26ba\u0003\u0002\u0002\u0002\u26be", + "\u26bb\u0003\u0002\u0002\u0002\u26be\u26bd\u0003\u0002\u0002\u0002\u26bf", + "\u0581\u0003\u0002\u0002\u0002\u26c0\u26c1\u0005\u03ba\u01de\u0002\u26c1", + "\u0583\u0003\u0002\u0002\u0002\u26c2\u26c8\u0003\u0002\u0002\u0002\u26c3", + "\u26c4\u0007\u0004\u0002\u0002\u26c4\u26c5\u0005\u0586\u02c4\u0002\u26c5", + "\u26c6\u0007\u0005\u0002\u0002\u26c6\u26c8\u0003\u0002\u0002\u0002\u26c7", + "\u26c2\u0003\u0002\u0002\u0002\u26c7\u26c3\u0003\u0002\u0002\u0002\u26c8", + "\u0585\u0003\u0002\u0002\u0002\u26c9\u26ce\u0005\u0588\u02c5\u0002\u26ca", + "\u26cb\u0007\b\u0002\u0002\u26cb\u26cd\u0005\u0588\u02c5\u0002\u26cc", + "\u26ca\u0003\u0002\u0002\u0002\u26cd\u26d0\u0003\u0002\u0002\u0002\u26ce", + "\u26cc\u0003\u0002\u0002\u0002\u26ce\u26cf\u0003\u0002\u0002\u0002\u26cf", + "\u0587\u0003\u0002\u0002\u0002\u26d0\u26ce\u0003\u0002\u0002\u0002\u26d1", + "\u26d2\u0005\u058e\u02c8\u0002\u26d2\u26d3\u0005\u0592\u02ca\u0002\u26d3", + "\u0589\u0003\u0002\u0002\u0002\u26d4\u26d5\t>\u0002\u0002\u26d5\u058b", + "\u0003\u0002\u0002\u0002\u26d6\u26d9\u0007\u001e\u0002\u0002\u26d7\u26d9", + "\u0005\u0552\u02aa\u0002\u26d8\u26d6\u0003\u0002\u0002\u0002\u26d8\u26d7", + "\u0003\u0002\u0002\u0002\u26d9\u058d\u0003\u0002\u0002\u0002\u26da\u26db", + "\u0005\u0638\u031d\u0002\u26db\u058f\u0003\u0002\u0002\u0002\u26dc\u26df", + "\u0003\u0002\u0002\u0002\u26dd\u26df\u0007\u01ea\u0002\u0002\u26de\u26dc", + "\u0003\u0002\u0002\u0002\u26de\u26dd\u0003\u0002\u0002\u0002\u26df\u0591", + "\u0003\u0002\u0002\u0002\u26e0\u26e1\u0005\u0456\u022c\u0002\u26e1\u0593", + "\u0003\u0002\u0002\u0002\u26e2\u26e6\u0003\u0002\u0002\u0002\u26e3\u26e4", + "\u0007-\u0002\u0002\u26e4\u26e6\u0005\u020e\u0108\u0002\u26e5\u26e2", + "\u0003\u0002\u0002\u0002\u26e5\u26e3\u0003\u0002\u0002\u0002\u26e6\u0595", + "\u0003\u0002\u0002\u0002\u26e7\u26eb\u0003\u0002\u0002\u0002\u26e8\u26e9", + "\u0007O\u0002\u0002\u26e9\u26eb\u0007P\u0002\u0002\u26ea\u26e7\u0003", + "\u0002\u0002\u0002\u26ea\u26e8\u0003\u0002\u0002\u0002\u26eb\u0597\u0003", + "\u0002\u0002\u0002\u26ec\u26f1\u0003\u0002\u0002\u0002\u26ed\u26ee\u0005", + "\u059a\u02ce\u0002\u26ee\u26ef\u0005\u063c\u031f\u0002\u26ef\u26f1\u0003", + "\u0002\u0002\u0002\u26f0\u26ec\u0003\u0002\u0002\u0002\u26f0\u26ed\u0003", + "\u0002\u0002\u0002\u26f1\u0599\u0003\u0002\u0002\u0002\u26f2\u26f5\u0005", + "\u059c\u02cf\u0002\u26f3\u26f5\u00077\u0002\u0002\u26f4\u26f2\u0003", + "\u0002\u0002\u0002\u26f4\u26f3\u0003\u0002\u0002\u0002\u26f5\u059b\u0003", + "\u0002\u0002\u0002\u26f6\u26f7\t?\u0002\u0002\u26f7\u059d\u0003\u0002", + "\u0002\u0002\u26f8\u26fa\u0005\u05a0\u02d1\u0002\u26f9\u26f8\u0003\u0002", + "\u0002\u0002\u26fa\u26fd\u0003\u0002\u0002\u0002\u26fb\u26f9\u0003\u0002", + "\u0002\u0002\u26fb\u26fc\u0003\u0002\u0002\u0002\u26fc\u059f\u0003\u0002", + "\u0002\u0002\u26fd\u26fb\u0003\u0002\u0002\u0002\u26fe\u26ff\u0005\u0572", + "\u02ba\u0002\u26ff\u2700\u0007\t\u0002\u0002\u2700\u271a\u0003\u0002", + "\u0002\u0002\u2701\u271a\u0005\u05e2\u02f2\u0002\u2702\u271a\u0005\u05e6", + "\u02f4\u0002\u2703\u271a\u0005\u05a8\u02d5\u0002\u2704\u271a\u0005\u05b8", + "\u02dd\u0002\u2705\u271a\u0005\u05be\u02e0\u0002\u2706\u271a\u0005\u05c8", + "\u02e5\u0002\u2707\u271a\u0005\u05ca\u02e6\u0002\u2708\u271a\u0005\u05cc", + "\u02e7\u0002\u2709\u271a\u0005\u05da\u02ee\u0002\u270a\u271a\u0005\u05de", + "\u02f0\u0002\u270b\u271a\u0005\u05f2\u02fa\u0002\u270c\u271a\u0005\u05f8", + "\u02fd\u0002\u270d\u271a\u0005\u05fa\u02fe\u0002\u270e\u271a\u0005\u05a2", + "\u02d2\u0002\u270f\u271a\u0005\u05a4\u02d3\u0002\u2710\u271a\u0005\u05aa", + "\u02d6\u0002\u2711\u271a\u0005\u0602\u0302\u0002\u2712\u271a\u0005\u060e", + "\u0308\u0002\u2713\u271a\u0005\u0616\u030c\u0002\u2714\u271a\u0005\u0618", + "\u030d\u0002\u2715\u271a\u0005\u061a\u030e\u0002\u2716\u271a\u0005\u061c", + "\u030f\u0002\u2717\u271a\u0005\u061e\u0310\u0002\u2718\u271a\u0005\u0622", + "\u0312\u0002\u2719\u26fe\u0003\u0002\u0002\u0002\u2719\u2701\u0003\u0002", + "\u0002\u0002\u2719\u2702\u0003\u0002\u0002\u0002\u2719\u2703\u0003\u0002", + "\u0002\u0002\u2719\u2704\u0003\u0002\u0002\u0002\u2719\u2705\u0003\u0002", + "\u0002\u0002\u2719\u2706\u0003\u0002\u0002\u0002\u2719\u2707\u0003\u0002", + "\u0002\u0002\u2719\u2708\u0003\u0002\u0002\u0002\u2719\u2709\u0003\u0002", + "\u0002\u0002\u2719\u270a\u0003\u0002\u0002\u0002\u2719\u270b\u0003\u0002", + "\u0002\u0002\u2719\u270c\u0003\u0002\u0002\u0002\u2719\u270d\u0003\u0002", + "\u0002\u0002\u2719\u270e\u0003\u0002\u0002\u0002\u2719\u270f\u0003\u0002", + "\u0002\u0002\u2719\u2710\u0003\u0002\u0002\u0002\u2719\u2711\u0003\u0002", + "\u0002\u0002\u2719\u2712\u0003\u0002\u0002\u0002\u2719\u2713\u0003\u0002", + "\u0002\u0002\u2719\u2714\u0003\u0002\u0002\u0002\u2719\u2715\u0003\u0002", + "\u0002\u0002\u2719\u2716\u0003\u0002\u0002\u0002\u2719\u2717\u0003\u0002", + "\u0002\u0002\u2719\u2718\u0003\u0002\u0002\u0002\u271a\u05a1\u0003\u0002", + "\u0002\u0002\u271b\u271c\u0007\u01eb\u0002\u0002\u271c\u271d\u0005\u0640", + "\u0321\u0002\u271d\u271e\u0007\t\u0002\u0002\u271e\u05a3\u0003\u0002", + "\u0002\u0002\u271f\u2720\u0007\u01aa\u0002\u0002\u2720\u2721\u0005\u0638", + "\u031d\u0002\u2721\u2722\u0007\u0004\u0002\u0002\u2722\u2723\u0005\u05a6", + "\u02d4\u0002\u2723\u2724\u0007\u0005\u0002\u0002\u2724\u2725\u0007\t", + "\u0002\u0002\u2725\u272e\u0003\u0002\u0002\u0002\u2726\u2727\u0007;", + "\u0002\u0002\u2727\u2728\u0005\u0638\u031d\u0002\u2728\u2729\u0007\u0004", + "\u0002\u0002\u2729\u272a\u0005\u05a6\u02d4\u0002\u272a\u272b\u0007\u0005", + "\u0002\u0002\u272b\u272c\u0007\t\u0002\u0002\u272c\u272e\u0003\u0002", + "\u0002\u0002\u272d\u271f\u0003\u0002\u0002\u0002\u272d\u2726\u0003\u0002", + "\u0002\u0002\u272e\u05a5\u0003\u0002\u0002\u0002\u272f\u2732\u0003\u0002", + "\u0002\u0002\u2730\u2732\u0005\u04f6\u027c\u0002\u2731\u272f\u0003\u0002", + "\u0002\u0002\u2731\u2730\u0003\u0002\u0002\u0002\u2732\u05a7\u0003\u0002", + "\u0002\u0002\u2733\u2734\u0005\u05b6\u02dc\u0002\u2734\u2735\u0005\u059c", + "\u02cf\u0002\u2735\u2736\u0005\u063c\u031f\u0002\u2736\u2737\u0007\t", + "\u0002\u0002\u2737\u05a9\u0003\u0002\u0002\u0002\u2738\u2739\u0007\u01ec", + "\u0002\u0002\u2739\u273a\u0005\u05ac\u02d7\u0002\u273a\u273b\u0007\u01ed", + "\u0002\u0002\u273b\u273c\u0005\u05ae\u02d8\u0002\u273c\u273d\u0007\t", + "\u0002\u0002\u273d\u05ab\u0003\u0002\u0002\u0002\u273e\u2742\u0003\u0002", + "\u0002\u0002\u273f\u2742\u0007\u01ab\u0002\u0002\u2740\u2742\u0007\u01ee", + "\u0002\u0002\u2741\u273e\u0003\u0002\u0002\u0002\u2741\u273f\u0003\u0002", + "\u0002\u0002\u2741\u2740\u0003\u0002\u0002\u0002\u2742\u05ad\u0003\u0002", + "\u0002\u0002\u2743\u2748\u0005\u05b0\u02d9\u0002\u2744\u2745\u0007\b", + "\u0002\u0002\u2745\u2747\u0005\u05b0\u02d9\u0002\u2746\u2744\u0003\u0002", + "\u0002\u0002\u2747\u274a\u0003\u0002\u0002\u0002\u2748\u2746\u0003\u0002", + "\u0002\u0002\u2748\u2749\u0003\u0002\u0002\u0002\u2749\u05af\u0003\u0002", + "\u0002\u0002\u274a\u2748\u0003\u0002\u0002\u0002\u274b\u274c\u0005\u05b4", + "\u02db\u0002\u274c\u274d\u0005\u059c\u02cf\u0002\u274d\u274e\u0005\u05b2", + "\u02da\u0002\u274e\u05b1\u0003\u0002\u0002\u0002\u274f\u2750\u0005\u0552", + "\u02aa\u0002\u2750\u05b3\u0003\u0002\u0002\u0002\u2751\u2752\u0005\u05b6", + "\u02dc\u0002\u2752\u05b5\u0003\u0002\u0002\u0002\u2753\u2756\u0005\u020e", + "\u0108\u0002\u2754\u2756\u0007\u001e\u0002\u0002\u2755\u2753\u0003\u0002", + "\u0002\u0002\u2755\u2754\u0003\u0002\u0002\u0002\u2756\u275d\u0003\u0002", + "\u0002\u0002\u2757\u2758\u0007\u0006\u0002\u0002\u2758\u2759\u0005\u0642", + "\u0322\u0002\u2759\u275a\u0007\u0007\u0002\u0002\u275a\u275c\u0003\u0002", + "\u0002\u0002\u275b\u2757\u0003\u0002\u0002\u0002\u275c\u275f\u0003\u0002", + "\u0002\u0002\u275d\u275b\u0003\u0002\u0002\u0002\u275d\u275e\u0003\u0002", + "\u0002\u0002\u275e\u05b7\u0003\u0002\u0002\u0002\u275f\u275d\u0003\u0002", + "\u0002\u0002\u2760\u2761\u0007\u00de\u0002\u0002\u2761\u2762\u0005\u063e", + "\u0320\u0002\u2762\u2763\u0007_\u0002\u0002\u2763\u2764\u0005\u059e", + "\u02d0\u0002\u2764\u2765\u0005\u05ba\u02de\u0002\u2765\u2766\u0005\u05bc", + "\u02df\u0002\u2766\u2767\u0007\u01bf\u0002\u0002\u2767\u2768\u0007\u00de", + "\u0002\u0002\u2768\u2769\u0007\t\u0002\u0002\u2769\u05b9\u0003\u0002", + "\u0002\u0002\u276a\u276b\u0007\u01ef\u0002\u0002\u276b\u276c\u0005\u0482", + "\u0242\u0002\u276c\u276d\u0007_\u0002\u0002\u276d\u276e\u0005\u059e", + "\u02d0\u0002\u276e\u2770\u0003\u0002\u0002\u0002\u276f\u276a\u0003\u0002", + "\u0002\u0002\u2770\u2773\u0003\u0002\u0002\u0002\u2771\u276f\u0003\u0002", + "\u0002\u0002\u2771\u2772\u0003\u0002\u0002\u0002\u2772\u05bb\u0003\u0002", + "\u0002\u0002\u2773\u2771\u0003\u0002\u0002\u0002\u2774\u2778\u0003\u0002", + "\u0002\u0002\u2775\u2776\u0007<\u0002\u0002\u2776\u2778\u0005\u059e", + "\u02d0\u0002\u2777\u2774\u0003\u0002\u0002\u0002\u2777\u2775\u0003\u0002", + "\u0002\u0002\u2778\u05bd\u0003\u0002\u0002\u0002\u2779\u277a\u0007*", + "\u0002\u0002\u277a\u277b\u0005\u05c0\u02e1\u0002\u277b\u277c\u0005\u05c2", + "\u02e2\u0002\u277c\u277d\u0005\u05c6\u02e4\u0002\u277d\u277e\u0007\u01bf", + "\u0002\u0002\u277e\u277f\u0007*\u0002\u0002\u277f\u2780\u0007\t\u0002", + "\u0002\u2780\u05bf\u0003\u0002\u0002\u0002\u2781\u2784\u0003\u0002\u0002", + "\u0002\u2782\u2784\u0005\u063c\u031f\u0002\u2783\u2781\u0003\u0002\u0002", + "\u0002\u2783\u2782\u0003\u0002\u0002\u0002\u2784\u05c1\u0003\u0002\u0002", + "\u0002\u2785\u2787\u0005\u05c4\u02e3\u0002\u2786\u2785\u0003\u0002\u0002", + "\u0002\u2787\u2788\u0003\u0002\u0002\u0002\u2788\u2786\u0003\u0002\u0002", + "\u0002\u2788\u2789\u0003\u0002\u0002\u0002\u2789\u05c3\u0003\u0002\u0002", + "\u0002\u278a\u278b\u0007h\u0002\u0002\u278b\u278c\u0005\u04f6\u027c", + "\u0002\u278c\u278d\u0007_\u0002\u0002\u278d\u278e\u0005\u059e\u02d0", + "\u0002\u278e\u05c5\u0003\u0002\u0002\u0002\u278f\u2793\u0003\u0002\u0002", + "\u0002\u2790\u2791\u0007<\u0002\u0002\u2791\u2793\u0005\u059e\u02d0", + "\u0002\u2792\u278f\u0003\u0002\u0002\u0002\u2792\u2790\u0003\u0002\u0002", + "\u0002\u2793\u05c7\u0003\u0002\u0002\u0002\u2794\u2795\u0005\u0632\u031a", + "\u0002\u2795\u2796\u0005\u05f6\u02fc\u0002\u2796\u05c9\u0003\u0002\u0002", + "\u0002\u2797\u2798\u0005\u0632\u031a\u0002\u2798\u2799\u0007\u01f0\u0002", + "\u0002\u2799\u279a\u0005\u0644\u0323\u0002\u279a\u279b\u0005\u05f6\u02fc", + "\u0002\u279b\u05cb\u0003\u0002\u0002\u0002\u279c\u279d\u0005\u0632\u031a", + "\u0002\u279d\u279e\u0007@\u0002\u0002\u279e\u279f\u0005\u05ce\u02e8", + "\u0002\u279f\u27a0\u0005\u05f6\u02fc\u0002\u27a0\u05cd\u0003\u0002\u0002", + "\u0002\u27a1\u27a2\u0005\u05d8\u02ed\u0002\u27a2\u27b2\u0007F\u0002", + "\u0002\u27a3\u27a4\u0005\u03b4\u01db\u0002\u27a4\u27a5\u0005\u05d2\u02ea", + "\u0002\u27a5\u27b3\u0003\u0002\u0002\u0002\u27a6\u27b3\u0005\u03ba\u01de", + "\u0002\u27a7\u27b3\u0005\u0370\u01b9\u0002\u27a8\u27a9\u0007\u00cc\u0002", + "\u0002\u27a9\u27aa\u0005\u0482\u0242\u0002\u27aa\u27ab\u0005\u05d0\u02e9", + "\u0002\u27ab\u27b3\u0003\u0002\u0002\u0002\u27ac\u27ad\u0005\u05d4\u02eb", + "\u0002\u27ad\u27ae\u0005\u0482\u0242\u0002\u27ae\u27af\u0007\u001a\u0002", + "\u0002\u27af\u27b0\u0005\u0482\u0242\u0002\u27b0\u27b1\u0005\u05d6\u02ec", + "\u0002\u27b1\u27b3\u0003\u0002\u0002\u0002\u27b2\u27a3\u0003\u0002\u0002", + "\u0002\u27b2\u27a6\u0003\u0002\u0002\u0002\u27b2\u27a7\u0003\u0002\u0002", + "\u0002\u27b2\u27a8\u0003\u0002\u0002\u0002\u27b2\u27ac\u0003\u0002\u0002", + "\u0002\u27b3\u05cf\u0003\u0002\u0002\u0002\u27b4\u27b8\u0003\u0002\u0002", + "\u0002\u27b5\u27b6\u0007f\u0002\u0002\u27b6\u27b8\u0005\u04f6\u027c", + "\u0002\u27b7\u27b4\u0003\u0002\u0002\u0002\u27b7\u27b5\u0003\u0002\u0002", + "\u0002\u27b8\u05d1\u0003\u0002\u0002\u0002\u27b9\u27c6\u0003\u0002\u0002", + "\u0002\u27ba\u27bb\u0007\u0004\u0002\u0002\u27bb\u27c0\u0005\u0482\u0242", + "\u0002\u27bc\u27bd\u0007\b\u0002\u0002\u27bd\u27bf\u0005\u0482\u0242", + "\u0002\u27be\u27bc\u0003\u0002\u0002\u0002\u27bf\u27c2\u0003\u0002\u0002", + "\u0002\u27c0\u27be\u0003\u0002\u0002\u0002\u27c0\u27c1\u0003\u0002\u0002", + "\u0002\u27c1\u27c3\u0003\u0002\u0002\u0002\u27c2\u27c0\u0003\u0002\u0002", + "\u0002\u27c3\u27c4\u0007\u0005\u0002\u0002\u27c4\u27c6\u0003\u0002\u0002", + "\u0002\u27c5\u27b9\u0003\u0002\u0002\u0002\u27c5\u27ba\u0003\u0002\u0002", + "\u0002\u27c6\u05d3\u0003\u0002\u0002\u0002\u27c7\u27ca\u0003\u0002\u0002", + "\u0002\u27c8\u27ca\u0007\u01f1\u0002\u0002\u27c9\u27c7\u0003\u0002\u0002", + "\u0002\u27c9\u27c8\u0003\u0002\u0002\u0002\u27ca\u05d5\u0003\u0002\u0002", + "\u0002\u27cb\u27cf\u0003\u0002\u0002\u0002\u27cc\u27cd\u0007\u0095\u0002", + "\u0002\u27cd\u27cf\u0005\u0482\u0242\u0002\u27ce\u27cb\u0003\u0002\u0002", + "\u0002\u27ce\u27cc\u0003\u0002\u0002\u0002\u27cf\u05d7\u0003\u0002\u0002", + "\u0002\u27d0\u27d1\u0005\u020c\u0107\u0002\u27d1\u05d9\u0003\u0002\u0002", + "\u0002\u27d2\u27d3\u0005\u0632\u031a\u0002\u27d3\u27d4\u0007\u01f2\u0002", + "\u0002\u27d4\u27d5\u0005\u05d8\u02ed\u0002\u27d5\u27d6\u0005\u05dc\u02ef", + "\u0002\u27d6\u27d7\u0007F\u0002\u0002\u27d7\u27d8\u0007%\u0002\u0002", + "\u27d8\u27d9\u0005\u0482\u0242\u0002\u27d9\u27da\u0005\u05f6\u02fc\u0002", + "\u27da\u05db\u0003\u0002\u0002\u0002\u27db\u27df\u0003\u0002\u0002\u0002", + "\u27dc\u27dd\u0007\u01f3\u0002\u0002\u27dd\u27df\u0005\u0542\u02a2\u0002", + "\u27de\u27db\u0003\u0002\u0002\u0002\u27de\u27dc\u0003\u0002\u0002\u0002", + "\u27df\u05dd\u0003\u0002\u0002\u0002\u27e0\u27e1\u0005\u05e0\u02f1\u0002", + "\u27e1\u27e2\u0005\u0634\u031b\u0002\u27e2\u27e3\u0005\u0636\u031c\u0002", + "\u27e3\u27e4\u0007\t\u0002\u0002\u27e4\u05df\u0003\u0002\u0002\u0002", + "\u27e5\u27e6\t@\u0002\u0002\u27e6\u05e1\u0003\u0002\u0002\u0002\u27e7", + "\u27f3\u0007\u01f5\u0002\u0002\u27e8\u27e9\u0007\u0105\u0002\u0002\u27e9", + "\u27f4\u0005\u063c\u031f\u0002\u27ea\u27f0\u0007\u01f6\u0002\u0002\u27eb", + "\u27ec\u0007\u00cc\u0002\u0002\u27ec\u27ed\u0005\u0482\u0242\u0002\u27ed", + "\u27ee\u0005\u05d0\u02e9\u0002\u27ee\u27f1\u0003\u0002\u0002\u0002\u27ef", + "\u27f1\u0005\u03ba\u01de\u0002\u27f0\u27eb\u0003\u0002\u0002\u0002\u27f0", + "\u27ef\u0003\u0002\u0002\u0002\u27f1\u27f4\u0003\u0002\u0002\u0002\u27f2", + "\u27f4\u0005\u05e4\u02f3\u0002\u27f3\u27e8\u0003\u0002\u0002\u0002\u27f3", + "\u27ea\u0003\u0002\u0002\u0002\u27f3\u27f2\u0003\u0002\u0002\u0002\u27f4", + "\u27f5\u0003\u0002\u0002\u0002\u27f5\u27f6\u0007\t\u0002\u0002\u27f6", + "\u05e3\u0003\u0002\u0002\u0002\u27f7\u27fa\u0003\u0002\u0002\u0002\u27f8", + "\u27fa\u0005\u063c\u031f\u0002\u27f9\u27f7\u0003\u0002\u0002\u0002\u27f9", + "\u27f8\u0003\u0002\u0002\u0002\u27fa\u05e5\u0003\u0002\u0002\u0002\u27fb", + "\u27fc\u0007\u01f7\u0002\u0002\u27fc\u27fd\u0005\u05e8\u02f5\u0002\u27fd", + "\u27fe\u0005\u0544\u02a3\u0002\u27fe\u27ff\u0005\u05ea\u02f6\u0002\u27ff", + "\u2800\u0005\u05ec\u02f7\u0002\u2800\u2801\u0007\t\u0002\u0002\u2801", + "\u2816\u0003\u0002\u0002\u0002\u2802\u2803\u0007\u01f7\u0002\u0002\u2803", + "\u2804\u0005\u05e8\u02f5\u0002\u2804\u2805\u0005\u055a\u02ae\u0002\u2805", + "\u2806\u0005\u05ec\u02f7\u0002\u2806\u2807\u0007\t\u0002\u0002\u2807", + "\u2816\u0003\u0002\u0002\u0002\u2808\u2809\u0007\u01f7\u0002\u0002\u2809", + "\u280a\u0005\u05e8\u02f5\u0002\u280a\u280b\u0007\u01f8\u0002\u0002\u280b", + "\u280c\u0005\u0544\u02a3\u0002\u280c\u280d\u0005\u05ec\u02f7\u0002\u280d", + "\u280e\u0007\t\u0002\u0002\u280e\u2816\u0003\u0002\u0002\u0002\u280f", + "\u2810\u0007\u01f7\u0002\u0002\u2810\u2811\u0005\u05e8\u02f5\u0002\u2811", + "\u2812\u0005\u05ec\u02f7\u0002\u2812\u2813\u0007\t\u0002\u0002\u2813", + "\u2816\u0003\u0002\u0002\u0002\u2814\u2816\u0007\u01f7\u0002\u0002\u2815", + "\u27fb\u0003\u0002\u0002\u0002\u2815\u2802\u0003\u0002\u0002\u0002\u2815", + "\u2808\u0003\u0002\u0002\u0002\u2815\u280f\u0003\u0002\u0002\u0002\u2815", + "\u2814\u0003\u0002\u0002\u0002\u2816\u05e7\u0003\u0002\u0002\u0002\u2817", + "\u2820\u0003\u0002\u0002\u0002\u2818\u2820\u0003\u0002\u0002\u0002\u2819", + "\u2820\u0007\u01f9\u0002\u0002\u281a\u2820\u0007\u01fa\u0002\u0002\u281b", + "\u2820\u0007\u01fb\u0002\u0002\u281c\u2820\u0007\u01fc\u0002\u0002\u281d", + "\u2820\u0007\u01fd\u0002\u0002\u281e\u2820\u0007\u01fe\u0002\u0002\u281f", + "\u2817\u0003\u0002\u0002\u0002\u281f\u2818\u0003\u0002\u0002\u0002\u281f", + "\u2819\u0003\u0002\u0002\u0002\u281f\u281a\u0003\u0002\u0002\u0002\u281f", + "\u281b\u0003\u0002\u0002\u0002\u281f\u281c\u0003\u0002\u0002\u0002\u281f", + "\u281d\u0003\u0002\u0002\u0002\u281f\u281e\u0003\u0002\u0002\u0002\u2820", + "\u05e9\u0003\u0002\u0002\u0002\u2821\u2829\u0003\u0002\u0002\u0002\u2822", + "\u2823\u0007\b\u0002\u0002\u2823\u2825\u0005\u0482\u0242\u0002\u2824", + "\u2822\u0003\u0002\u0002\u0002\u2825\u2826\u0003\u0002\u0002\u0002\u2826", + "\u2824\u0003\u0002\u0002\u0002\u2826\u2827\u0003\u0002\u0002\u0002\u2827", + "\u2829\u0003\u0002\u0002\u0002\u2828\u2821\u0003\u0002\u0002\u0002\u2828", + "\u2824\u0003\u0002\u0002\u0002\u2829\u05eb\u0003\u0002\u0002\u0002\u282a", + "\u282e\u0003\u0002\u0002\u0002\u282b\u282c\u0007f\u0002\u0002\u282c", + "\u282e\u0005\u05f0\u02f9\u0002\u282d\u282a\u0003\u0002\u0002\u0002\u282d", + "\u282b\u0003\u0002\u0002\u0002\u282e\u05ed\u0003\u0002\u0002\u0002\u282f", + "\u2830\u0005\u055a\u02ae\u0002\u2830\u2831\u0007\f\u0002\u0002\u2831", + "\u2832\u0005\u0482\u0242\u0002\u2832\u05ef\u0003\u0002\u0002\u0002\u2833", + "\u2838\u0005\u05ee\u02f8\u0002\u2834\u2835\u0007\b\u0002\u0002\u2835", + "\u2837\u0005\u05ee\u02f8\u0002\u2836\u2834\u0003\u0002\u0002\u0002\u2837", + "\u283a\u0003\u0002\u0002\u0002\u2838\u2836\u0003\u0002\u0002\u0002\u2838", + "\u2839\u0003\u0002\u0002\u0002\u2839\u05f1\u0003\u0002\u0002\u0002\u283a", + "\u2838\u0003\u0002\u0002\u0002\u283b\u283c\u0007\u01ff\u0002\u0002\u283c", + "\u283d\u0005\u063c\u031f\u0002\u283d\u283e\u0005\u05f4\u02fb\u0002\u283e", + "\u283f\u0007\t\u0002\u0002\u283f\u05f3\u0003\u0002\u0002\u0002\u2840", + "\u2844\u0003\u0002\u0002\u0002\u2841\u2842\u0007\b\u0002\u0002\u2842", + "\u2844\u0005\u063c\u031f\u0002\u2843\u2840\u0003\u0002\u0002\u0002\u2843", + "\u2841\u0003\u0002\u0002\u0002\u2844\u05f5\u0003\u0002\u0002\u0002\u2845", + "\u2846\u0007\u0200\u0002\u0002\u2846\u2847\u0005\u059e\u02d0\u0002\u2847", + "\u2848\u0007\u01bf\u0002\u0002\u2848\u2849\u0007\u0200\u0002\u0002\u2849", + "\u284a\u0005\u0634\u031b\u0002\u284a\u284b\u0007\t\u0002\u0002\u284b", + "\u05f7\u0003\u0002\u0002\u0002\u284c\u284d\u0005\u0646\u0324\u0002\u284d", + "\u284e\u0007\t\u0002\u0002\u284e\u05f9\u0003\u0002\u0002\u0002\u284f", + "\u2850\u0007\u00cc\u0002\u0002\u2850\u2858\u0005\u0482\u0242\u0002\u2851", + "\u2852\u0005\u0600\u0301\u0002\u2852\u2853\u0005\u05fc\u02ff\u0002\u2853", + "\u2859\u0003\u0002\u0002\u0002\u2854\u2855\u0005\u05fc\u02ff\u0002\u2855", + "\u2856\u0005\u0600\u0301\u0002\u2856\u2859\u0003\u0002\u0002\u0002\u2857", + "\u2859\u0003\u0002\u0002\u0002\u2858\u2851\u0003\u0002\u0002\u0002\u2858", + "\u2854\u0003\u0002\u0002\u0002\u2858\u2857\u0003\u0002\u0002\u0002\u2859", + "\u285a\u0003\u0002\u0002\u0002\u285a\u285b\u0007\t\u0002\u0002\u285b", + "\u05fb\u0003\u0002\u0002\u0002\u285c\u2860\u0003\u0002\u0002\u0002\u285d", + "\u285e\u0007f\u0002\u0002\u285e\u2860\u0005\u05fe\u0300\u0002\u285f", + "\u285c\u0003\u0002\u0002\u0002\u285f\u285d\u0003\u0002\u0002\u0002\u2860", + "\u05fd\u0003\u0002\u0002\u0002\u2861\u2866\u0005\u0482\u0242\u0002\u2862", + "\u2863\u0007\b\u0002\u0002\u2863\u2865\u0005\u0482\u0242\u0002\u2864", + "\u2862\u0003\u0002\u0002\u0002\u2865\u2868\u0003\u0002\u0002\u0002\u2866", + "\u2864\u0003\u0002\u0002\u0002\u2866\u2867\u0003\u0002\u0002\u0002\u2867", + "\u05ff\u0003\u0002\u0002\u0002\u2868\u2866\u0003\u0002\u0002\u0002\u2869", + "\u2870\u0003\u0002\u0002\u0002\u286a\u286c\u0007I\u0002\u0002\u286b", + "\u286d\u0007\u0153\u0002\u0002\u286c\u286b\u0003\u0002\u0002\u0002\u286c", + "\u286d\u0003\u0002\u0002\u0002\u286d\u286e\u0003\u0002\u0002\u0002\u286e", + "\u2870\u0005\u0610\u0309\u0002\u286f\u2869\u0003\u0002\u0002\u0002\u286f", + "\u286a\u0003\u0002\u0002\u0002\u2870\u0601\u0003\u0002\u0002\u0002\u2871", + "\u2883\u0007\u0201\u0002\u0002\u2872\u2873\u0005\u0624\u0313\u0002\u2873", + "\u2874\u0005\u060a\u0306\u0002\u2874\u287a\u0007@\u0002\u0002\u2875", + "\u287b\u0005\u03ba\u01de\u0002\u2876\u2877\u0007\u00cc\u0002\u0002\u2877", + "\u2878\u0005\u063c\u031f\u0002\u2878\u2879\u0005\u0608\u0305\u0002\u2879", + "\u287b\u0003\u0002\u0002\u0002\u287a\u2875\u0003\u0002\u0002\u0002\u287a", + "\u2876\u0003\u0002\u0002\u0002\u287b\u2884\u0003\u0002\u0002\u0002\u287c", + "\u2881\u0005\u0552\u02aa\u0002\u287d\u287e\u0007\u0004\u0002\u0002\u287e", + "\u287f\u0005\u0606\u0304\u0002\u287f\u2880\u0007\u0005\u0002\u0002\u2880", + "\u2882\u0003\u0002\u0002\u0002\u2881\u287d\u0003\u0002\u0002\u0002\u2881", + "\u2882\u0003\u0002\u0002\u0002\u2882\u2884\u0003\u0002\u0002\u0002\u2883", + "\u2872\u0003\u0002\u0002\u0002\u2883\u287c\u0003\u0002\u0002\u0002\u2884", + "\u2885\u0003\u0002\u0002\u0002\u2885\u2886\u0007\t\u0002\u0002\u2886", + "\u0603\u0003\u0002\u0002\u0002\u2887\u2888\u0005\u0552\u02aa\u0002\u2888", + "\u2889\u0007\u0016\u0002\u0002\u2889\u288a\u0005\u0482\u0242\u0002\u288a", + "\u288d\u0003\u0002\u0002\u0002\u288b\u288d\u0005\u0482\u0242\u0002\u288c", + "\u2887\u0003\u0002\u0002\u0002\u288c\u288b\u0003\u0002\u0002\u0002\u288d", + "\u0605\u0003\u0002\u0002\u0002\u288e\u2893\u0005\u0604\u0303\u0002\u288f", + "\u2890\u0007\b\u0002\u0002\u2890\u2892\u0005\u0604\u0303\u0002\u2891", + "\u288f\u0003\u0002\u0002\u0002\u2892\u2895\u0003\u0002\u0002\u0002\u2893", + "\u2891\u0003\u0002\u0002\u0002\u2893\u2894\u0003\u0002\u0002\u0002\u2894", + "\u0607\u0003\u0002\u0002\u0002\u2895\u2893\u0003\u0002\u0002\u0002\u2896", + "\u289a\u0003\u0002\u0002\u0002\u2897\u2898\u0007f\u0002\u0002\u2898", + "\u289a\u0005\u04f6\u027c\u0002\u2899\u2896\u0003\u0002\u0002\u0002\u2899", + "\u2897\u0003\u0002\u0002\u0002\u289a\u0609\u0003\u0002\u0002\u0002\u289b", + "\u28a0\u0003\u0002\u0002\u0002\u289c\u289d\u0005\u060c\u0307\u0002\u289d", + "\u289e\u0007\u013d\u0002\u0002\u289e\u28a0\u0003\u0002\u0002\u0002\u289f", + "\u289b\u0003\u0002\u0002\u0002\u289f\u289c\u0003\u0002\u0002\u0002\u28a0", + "\u060b\u0003\u0002\u0002\u0002\u28a1\u28a4\u0003\u0002\u0002\u0002\u28a2", + "\u28a4\u0007\u0106\u0002\u0002\u28a3\u28a1\u0003\u0002\u0002\u0002\u28a3", + "\u28a2\u0003\u0002\u0002\u0002\u28a4\u060d\u0003\u0002\u0002\u0002\u28a5", + "\u28a6\u0007?\u0002\u0002\u28a6\u28a7\u0005\u0614\u030b\u0002\u28a7", + "\u28a8\u0005\u0612\u030a\u0002\u28a8\u28a9\u0005\u0624\u0313\u0002\u28a9", + "\u28aa\u0007I\u0002\u0002\u28aa\u28ab\u0005\u0610\u0309\u0002\u28ab", + "\u28ac\u0007\t\u0002\u0002\u28ac\u060f\u0003\u0002\u0002\u0002\u28ad", + "\u28ae\u0005\u04f6\u027c\u0002\u28ae\u0611\u0003\u0002\u0002\u0002\u28af", + "\u28b3\u0003\u0002\u0002\u0002\u28b0\u28b3\u0007B\u0002\u0002\u28b1", + "\u28b3\u0007F\u0002\u0002\u28b2\u28af\u0003\u0002\u0002\u0002\u28b2", + "\u28b0\u0003\u0002\u0002\u0002\u28b2\u28b1\u0003\u0002\u0002\u0002\u28b3", + "\u0613\u0003\u0002\u0002\u0002\u28b4\u28c6\u0003\u0002\u0002\u0002\u28b5", + "\u28c6\u0003\u0002\u0002\u0002\u28b6\u28c6\u0007\u0105\u0002\u0002\u28b7", + "\u28c6\u0007\u011e\u0002\u0002\u28b8\u28c6\u0007\u00d1\u0002\u0002\u28b9", + "\u28c6\u0007\u00f2\u0002\u0002\u28ba\u28bb\u0007\u0084\u0002\u0002\u28bb", + "\u28c6\u0005\u0482\u0242\u0002\u28bc\u28bd\u0007\u012c\u0002\u0002\u28bd", + "\u28c6\u0005\u0482\u0242\u0002\u28be\u28c6\u0005\u0482\u0242\u0002\u28bf", + "\u28c6\u0007 \u0002\u0002\u28c0\u28c3\tA\u0002\u0002\u28c1\u28c4\u0005", + "\u0482\u0242\u0002\u28c2\u28c4\u0007 \u0002\u0002\u28c3\u28c1\u0003", + "\u0002\u0002\u0002\u28c3\u28c2\u0003\u0002\u0002\u0002\u28c3\u28c4\u0003", + "\u0002\u0002\u0002\u28c4\u28c6\u0003\u0002\u0002\u0002\u28c5\u28b4\u0003", + "\u0002\u0002\u0002\u28c5\u28b5\u0003\u0002\u0002\u0002\u28c5\u28b6\u0003", + "\u0002\u0002\u0002\u28c5\u28b7\u0003\u0002\u0002\u0002\u28c5\u28b8\u0003", + "\u0002\u0002\u0002\u28c5\u28b9\u0003\u0002\u0002\u0002\u28c5\u28ba\u0003", + "\u0002\u0002\u0002\u28c5\u28bc\u0003\u0002\u0002\u0002\u28c5\u28be\u0003", + "\u0002\u0002\u0002\u28c5\u28bf\u0003\u0002\u0002\u0002\u28c5\u28c0\u0003", + "\u0002\u0002\u0002\u28c6\u0615\u0003\u0002\u0002\u0002\u28c7\u28c8\u0007", + "\u0102\u0002\u0002\u28c8\u28c9\u0005\u0614\u030b\u0002\u28c9\u28ca\u0005", + "\u0624\u0313\u0002\u28ca\u28cb\u0007\t\u0002\u0002\u28cb\u0617\u0003", + "\u0002\u0002\u0002\u28cc\u28cd\u0007\u009f\u0002\u0002\u28cd\u28ce\u0005", + "\u0624\u0313\u0002\u28ce\u28cf\u0007\t\u0002\u0002\u28cf\u0619\u0003", + "\u0002\u0002\u0002\u28d0\u28d1\u0007P\u0002\u0002\u28d1\u28d2\u0007", + "\t\u0002\u0002\u28d2\u061b\u0003\u0002\u0002\u0002\u28d3\u28d4\u0007", + "\u00a3\u0002\u0002\u28d4\u28d5\u0005\u0620\u0311\u0002\u28d5\u28d6\u0007", + "\t\u0002\u0002\u28d6\u061d\u0003\u0002\u0002\u0002\u28d7\u28d8\u0007", + "\u0138\u0002\u0002\u28d8\u28d9\u0005\u0620\u0311\u0002\u28d9\u28da\u0007", + "\t\u0002\u0002\u28da\u061f\u0003\u0002\u0002\u0002\u28db\u28dd\u0007", + "#\u0002\u0002\u28dc\u28de\u0007\u0106\u0002\u0002\u28dd\u28dc\u0003", + "\u0002\u0002\u0002\u28dd\u28de\u0003\u0002\u0002\u0002\u28de\u28df\u0003", + "\u0002\u0002\u0002\u28df\u28e2\u0007\u009b\u0002\u0002\u28e0\u28e2\u0003", + "\u0002\u0002\u0002\u28e1\u28db\u0003\u0002\u0002\u0002\u28e1\u28e0\u0003", + "\u0002\u0002\u0002\u28e2\u0621\u0003\u0002\u0002\u0002\u28e3\u28e4\u0007", + "\u0146\u0002\u0002\u28e4\u28e5\u0005\u020e\u0108\u0002\u28e5\u28e6\u0007", + "`\u0002\u0002\u28e6\u28e7\u00077\u0002\u0002\u28e7\u28e8\u0007\t\u0002", + "\u0002\u28e8\u28f0\u0003\u0002\u0002\u0002\u28e9\u28ec\u0007\u0132\u0002", + "\u0002\u28ea\u28ed\u0005\u020e\u0108\u0002\u28eb\u28ed\u0007 \u0002", + "\u0002\u28ec\u28ea\u0003\u0002\u0002\u0002\u28ec\u28eb\u0003\u0002\u0002", + "\u0002\u28ed\u28ee\u0003\u0002\u0002\u0002\u28ee\u28f0\u0007\t\u0002", + "\u0002\u28ef\u28e3\u0003\u0002\u0002\u0002\u28ef\u28e9\u0003\u0002\u0002", + "\u0002\u28f0\u0623\u0003\u0002\u0002\u0002\u28f1\u28f4\u0005\u0552\u02aa", + "\u0002\u28f2\u28f4\u0007\u001e\u0002\u0002\u28f3\u28f1\u0003\u0002\u0002", + "\u0002\u28f3\u28f2\u0003\u0002\u0002\u0002\u28f4\u0625\u0003\u0002\u0002", + "\u0002\u28f5\u28f9\u0003\u0002\u0002\u0002\u28f6\u28f7\u0007\u01fe\u0002", + "\u0002\u28f7\u28f9\u0005\u0628\u0315\u0002\u28f8\u28f5\u0003\u0002\u0002", + "\u0002\u28f8\u28f6\u0003\u0002\u0002\u0002\u28f9\u0627\u0003\u0002\u0002", + "\u0002\u28fa\u28fc\u0005\u062a\u0316\u0002\u28fb\u28fa\u0003\u0002\u0002", + "\u0002\u28fc\u28fd\u0003\u0002\u0002\u0002\u28fd\u28fb\u0003\u0002\u0002", + "\u0002\u28fd\u28fe\u0003\u0002\u0002\u0002\u28fe\u0629\u0003\u0002\u0002", + "\u0002\u28ff\u2900\u0007h\u0002\u0002\u2900\u2901\u0005\u062c\u0317", + "\u0002\u2901\u2902\u0007_\u0002\u0002\u2902\u2903\u0005\u059e\u02d0", + "\u0002\u2903\u062b\u0003\u0002\u0002\u0002\u2904\u2909\u0005\u062e\u0318", + "\u0002\u2905\u2906\u0007T\u0002\u0002\u2906\u2908\u0005\u062e\u0318", + "\u0002\u2907\u2905\u0003\u0002\u0002\u0002\u2908\u290b\u0003\u0002\u0002", + "\u0002\u2909\u2907\u0003\u0002\u0002\u0002\u2909\u290a\u0003\u0002\u0002", + "\u0002\u290a\u062d\u0003\u0002\u0002\u0002\u290b\u2909\u0003\u0002\u0002", + "\u0002\u290c\u2910\u0005\u0638\u031d\u0002\u290d\u290e\u0007\u01f8\u0002", + "\u0002\u290e\u2910\u0005\u0544\u02a3\u0002\u290f\u290c\u0003\u0002\u0002", + "\u0002\u290f\u290d\u0003\u0002\u0002\u0002\u2910\u062f\u0003\u0002\u0002", + "\u0002\u2911\u2914\u0003\u0002\u0002\u0002\u2912\u2914\u0005\u057a\u02be", + "\u0002\u2913\u2911\u0003\u0002\u0002\u0002\u2913\u2912\u0003\u0002\u0002", + "\u0002\u2914\u0631\u0003\u0002\u0002\u0002\u2915\u2918\u0003\u0002\u0002", + "\u0002\u2916\u2918\u0005\u057a\u02be\u0002\u2917\u2915\u0003\u0002\u0002", + "\u0002\u2917\u2916\u0003\u0002\u0002\u0002\u2918\u0633\u0003\u0002\u0002", + "\u0002\u2919\u291c\u0003\u0002\u0002\u0002\u291a\u291c\u0005\u0638\u031d", + "\u0002\u291b\u2919\u0003\u0002\u0002\u0002\u291b\u291a\u0003\u0002\u0002", + "\u0002\u291c\u0635\u0003\u0002\u0002\u0002\u291d\u291e\u0007h\u0002", + "\u0002\u291e\u2921\u0005\u0640\u0321\u0002\u291f\u2921\u0003\u0002\u0002", + "\u0002\u2920\u291d\u0003\u0002\u0002\u0002\u2920\u291f\u0003\u0002\u0002", + "\u0002\u2921\u0637\u0003\u0002\u0002\u0002\u2922\u2925\u0005\u0552\u02aa", + "\u0002\u2923\u2925\u0005\u063a\u031e\u0002\u2924\u2922\u0003\u0002\u0002", + "\u0002\u2924\u2923\u0003\u0002\u0002\u0002\u2925\u0639\u0003\u0002\u0002", + "\u0002\u2926\u2927\tB\u0002\u0002\u2927\u063b\u0003\u0002\u0002\u0002", + "\u2928\u2929\u0005\u0526\u0294\u0002\u2929\u292a\u0005\u03d2\u01ea\u0002", + "\u292a\u292b\u0005\u041a\u020e\u0002\u292b\u292c\u0005\u043e\u0220\u0002", + "\u292c\u292d\u0005\u03fc\u01ff\u0002\u292d\u292e\u0005\u040a\u0206\u0002", + "\u292e\u292f\u0005\u04ce\u0268\u0002\u292f\u063d\u0003\u0002\u0002\u0002", + "\u2930\u2931\u0005\u063c\u031f\u0002\u2931\u063f\u0003\u0002\u0002\u0002", + "\u2932\u2933\u0005\u063c\u031f\u0002\u2933\u0641\u0003\u0002\u0002\u0002", + "\u2934\u2935\u0005\u0482\u0242\u0002\u2935\u0643\u0003\u0002\u0002\u0002", + "\u2936\u2937\u0005\u0482\u0242\u0002\u2937\u0645\u0003\u0002\u0002\u0002", + "\u2938\u2939\u0005\n\u0006\u0002\u2939\u293a\u0005\u0648\u0325\u0002", + "\u293a\u0647\u0003\u0002\u0002\u0002\u293b\u293c\u0007I\u0002\u0002", + "\u293c\u293d\u0005\u03d4\u01eb\u0002\u293d\u293e\u0005\u0610\u0309\u0002", + "\u293e\u2941\u0003\u0002\u0002\u0002\u293f\u2941\u0003\u0002\u0002\u0002", + "\u2940\u293b\u0003\u0002\u0002\u0002\u2940\u293f\u0003\u0002\u0002\u0002", + "\u2941\u0649\u0003\u0002\u0002\u0002\u02d4\u0653\u0657\u06d6\u06da\u06e7", + "\u06ec\u06f2\u06f8\u0707\u0713\u0725\u072a\u0734\u074c\u0753\u0759\u075e", + "\u0767\u076b\u0777\u0796\u079d\u07a5\u07aa\u07b1\u07b7\u07c8\u07cd\u07d1", + "\u07de\u07e2\u07e7\u07ec\u07f8\u0801\u080e\u0813\u081e\u0829\u082e\u0839", + "\u0844\u084d\u0857\u0866\u0872\u0877\u087e\u0889\u098b\u0992\u0997\u099c", + "\u09a1\u09a9\u09b2\u09b9\u09c3\u09c5\u09ca\u09d0\u09d6\u09d8\u09f4\u09fe", + "\u0a0b\u0a17\u0a25\u0a2a\u0a42\u0a48\u0a4d\u0a54\u0a59\u0a7f\u0a83\u0a8a", + "\u0a8e\u0a95\u0aa3\u0aaa\u0ab5\u0ad6\u0ae0\u0ae4\u0aeb\u0af2\u0afa\u0b00", + "\u0b04\u0b0e\u0b15\u0b20\u0b40\u0b48\u0b4d\u0b54\u0b5e\u0b68\u0b7c\u0b8b", + "\u0ba4\u0ba9\u0bb0\u0bb7\u0bc2\u0bc7\u0bce\u0bd9\u0be1\u0bec\u0bfc\u0c04", + "\u0c08\u0c16\u0c27\u0c2c\u0c33\u0c3c\u0c3f\u0c44\u0c4b\u0c56\u0c63\u0c70", + "\u0c82\u0c85\u0c8e\u0c9d\u0cac\u0cb5\u0cbc\u0cc3\u0cc8\u0ce6\u0ce8\u0cec", + "\u0cf4\u0cfb\u0d09\u0d0d\u0d11\u0d16\u0d1c\u0d20\u0d24\u0d31\u0d37\u0d40", + "\u0d49\u0d53\u0d5e\u0dcc\u0dde\u0de3\u0de7\u0df8\u0e00\u0e07\u0e14\u0e1e", + "\u0e40\u0e45\u0e4a\u0e4e\u0e56\u0e58\u0e92\u0ea3\u0eab\u0ec2\u0ec6\u0eda", + "\u0eff\u0f08\u0f0d\u0f12\u0f17\u0f1c\u0f51\u0f57\u0f5e\u0f68\u0f6d\u0f72", + "\u0f84\u0f88\u0f92\u0f98\u0f9e\u0fa5\u0faa\u0faf\u0fbd\u0fd9\u0fe0\u0fee", + "\u0ffd\u1072\u107d\u1083\u108b\u1096\u109f\u10a6\u10ce\u10d4\u10e9\u1105", + "\u1109\u110e\u1117\u111b\u1136\u113d\u114c\u1160\u1174\u11d1\u11ea\u11f1", + "\u1201\u120a\u120f\u1215\u121c\u122a\u12bf\u12c3\u1320\u1325\u1329\u132f", + "\u1373\u1379\u1396\u13a7\u13ae\u13ba\u13f6\u13fd\u1403\u1409\u1423\u1429", + "\u142f\u143a\u1446\u1463\u148a\u148e\u1492\u1496\u149b\u14a2\u14b0\u14bd", + "\u14c5\u14cc\u14d2\u14d6\u14db\u14e2\u14f0\u14f2\u14f9\u14fd\u1506\u150e", + "\u1517\u1519\u151d\u1526\u152b\u1531\u1536\u153a\u153f\u1551\u1556\u1565", + "\u156e\u1579\u157f\u15a6\u15b0\u15b7\u15c2\u15c8\u15d2\u15de\u15e2\u1608", + "\u1616\u1624\u163c\u1643\u164d\u1659\u165e\u1682\u1689\u1698\u16c7\u16ec", + "\u16f7\u1708\u18de\u18e2\u18e7\u1922\u1926\u1a01\u1a10\u1a1b\u1a22\u1ae3", + "\u1aed\u1af5\u1b12\u1b22\u1b4c\u1b5a\u1b70\u1b77\u1b7f\u1b83\u1b8a\u1b93", + "\u1b9c\u1bd0\u1bd5\u1be1\u1be5\u1bea\u1bef\u1bf3\u1bf7\u1bfc\u1c0c\u1c14", + "\u1c19\u1c26\u1c2b\u1c32\u1c3c\u1c40\u1c4b\u1c56\u1c5e\u1c65\u1c8c\u1c94", + "\u1c98\u1ce9\u1d05\u1d0a\u1d19\u1d25\u1d2c\u1d36\u1d3b\u1d3f\u1d43\u1d47", + "\u1d4b\u1d52\u1d5c\u1d61\u1d73\u1d7e\u1d85\u1d8d\u1d92\u1d9f\u1da5\u1dc2", + "\u1dc9\u1dd5\u1de2\u1df1\u1df7\u1e00\u1e10\u1e13\u1e1e\u1e23\u1e30\u1e3d", + "\u1e48\u1e4b\u1e4f\u1e55\u1e65\u1e72\u1e7c\u1e8e\u1e90\u1e98\u1e9c\u1ea6", + "\u1eb0\u1ebb\u1ebd\u1ec1\u1ecb\u1edb\u1edd\u1ee2\u1ee6\u1eec\u1ef3\u1efc", + "\u1f0b\u1f0f\u1f16\u1f19\u1f1d\u1f20\u1f2d\u1f31\u1f36\u1f3e\u1f42\u1f46", + "\u1f51\u1f58\u1f5e\u1f62\u1f64\u1f68\u1f6e\u1f77\u1f7d\u1f7f\u1f81\u1f88", + "\u1f8c\u1f95\u1f99\u1fa3\u1faa\u1fb2\u1fca\u1fd0\u1fd4\u1fd9\u1fe2\u1fe6", + "\u1fe9\u1fee\u1ffb\u2001\u2008\u200e\u2023\u202c\u2031\u2037\u203c\u2043", + "\u2048\u204e\u2050\u2054\u205b\u205f\u2064\u2067\u206e\u2072\u207b\u207f", + "\u2087\u2089\u2090\u2095\u2098\u20a7\u20b3\u20bd\u20c6\u20cb\u20d0\u20d7", + "\u20da\u20de\u20e5\u20fd\u2106\u210c\u2110\u2115\u211f\u2126\u212f\u2132", + "\u213b\u213d\u2143\u2147\u214c\u215a\u215c\u2162\u2166\u216f\u2181\u2188", + "\u218c\u2190\u21a0\u21a7\u21af\u21b3\u21ba\u21c7\u21d7\u21dd\u21e3\u21ea", + "\u21ef\u21f5\u21fc\u2204\u220c\u2211\u2215\u2218\u221e\u2223\u2233\u2236", + "\u2238\u2244\u2246\u224a\u2252\u2254\u2259\u2261\u2265\u226e\u2276\u227c", + "\u227f\u2288\u228d\u2294\u229e\u22b8\u22c3\u22c5\u22c7\u22cf\u22e6\u22ee", + "\u22f8\u2306\u2310\u2314\u2322\u2329\u2330\u2337\u2350\u236d\u2394\u2396", + "\u23b2\u23c7\u23ce\u23db\u23e7\u23ed\u23f6\u2407\u2413\u241c\u2421\u2428", + "\u2432\u2435\u2440\u2446\u2455\u245d\u2466\u246f\u2472\u2477\u2480\u2485", + "\u2493\u249d\u24a5\u24b3\u24ba\u24c2\u24ca\u24d1\u24d7\u24e0\u24e8\u24f2", + "\u24fd\u2504\u2522\u252b\u2532\u253d\u2547\u254b\u254f\u2554\u255c\u2560", + "\u2564\u2569\u256e\u2573\u257a\u2582\u2585\u258c\u2591\u2598\u25a5\u25b4", + "\u25c2\u25c7\u25da\u25df\u25e4\u25eb\u25f2\u25f9\u2600\u2606\u260c\u2614", + "\u261d\u2656\u2663\u267a\u2682\u2686\u2692\u2694\u269b\u26a4\u26b6\u26be", + "\u26c7\u26ce\u26d8\u26de\u26e5\u26ea\u26f0\u26f4\u26fb\u2719\u272d\u2731", + "\u2741\u2748\u2755\u275d\u2771\u2777\u2783\u2788\u2792\u27b2\u27b7\u27c0", + "\u27c5\u27c9\u27ce\u27de\u27f0\u27f3\u27f9\u2815\u281f\u2826\u2828\u282d", + "\u2838\u2843\u2858\u285f\u2866\u286c\u286f\u287a\u2881\u2883\u288c\u2893", + "\u2899\u289f\u28a3\u28b2\u28c3\u28c5\u28dd\u28e1\u28ec\u28ef\u28f3\u28f8", + "\u28fd\u2909\u290f\u2913\u2917\u291b\u2920\u2924\u2940"].join(""); + + +var atn = new antlr4.atn.ATNDeserializer().deserialize(serializedATN); + +var decisionsToDFA = atn.decisionToState.map( function(ds, index) { return new antlr4.dfa.DFA(ds, index); }); + +var sharedContextCache = new antlr4.PredictionContextCache(); + +var literalNames = [ null, "'$'", "'('", "')'", "'['", "']'", "','", "';'", + "':'", "'*'", "'='", "'.'", "'+'", "'-'", "'/'", "'^'", + "'<'", "'>'", "'<<'", "'>>'", "':='", "'<='", "'=>'", + "'>='", "'..'", "'<>'", "'::'", "'%'", null, null, + "'ALL'", "'ANALYSE'", "'ANALYZE'", "'AND'", "'ANY'", + "'ARRAY'", "'AS'", "'ASC'", "'ASYMMETRIC'", "'BOTH'", + "'CASE'", "'CAST'", "'CHECK'", "'COLLATE'", "'COLUMN'", + "'CONSTRAINT'", "'CREATE'", "'CURRENT_CATALOG'", "'CURRENT_DATE'", + "'CURRENT_ROLE'", "'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", + "'CURRENT_USER'", "'DEFAULT'", "'DEFERRABLE'", "'DESC'", + "'DISTINCT'", "'DO'", "'ELSE'", "'EXCEPT'", "'FALSE'", + "'FETCH'", "'FOR'", "'FOREIGN'", "'FROM'", "'GRANT'", + "'GROUP'", "'HAVING'", "'IN'", "'INITIALLY'", "'INTERSECT'", + "'INTO'", "'LATERAL'", "'LEADING'", "'LIMIT'", "'LOCALTIME'", + "'LOCALTIMESTAMP'", "'NOT'", "'NULL'", "'OFFSET'", + "'ON'", "'ONLY'", "'OR'", "'ORDER'", "'PLACING'", "'PRIMARY'", + "'REFERENCES'", "'RETURNING'", "'SELECT'", "'SESSION_USER'", + "'SOME'", "'SYMMETRIC'", "'TABLE'", "'THEN'", "'TO'", + "'TRAILING'", "'TRUE'", "'UNION'", "'UNIQUE'", "'USER'", + "'USING'", "'VARIADIC'", "'WHEN'", "'WHERE'", "'WINDOW'", + "'WITH'", "'AUTHORIZATION'", "'BINARY'", "'COLLATION'", + "'CONCURRENTLY'", "'CROSS'", "'CURRENT_SCHEMA'", "'FREEZE'", + "'FULL'", "'ILIKE'", "'INNER'", "'IS'", "'ISNULL'", + "'JOIN'", "'LEFT'", "'LIKE'", "'NATURAL'", "'NOTNULL'", + "'OUTER'", "'OVER'", "'OVERLAPS'", "'RIGHT'", "'SIMILAR'", + "'VERBOSE'", "'ABORT'", "'ABSOLUTE'", "'ACCESS'", "'ACTION'", + "'ADD'", "'ADMIN'", "'AFTER'", "'AGGREGATE'", "'ALSO'", + "'ALTER'", "'ALWAYS'", "'ASSERTION'", "'ASSIGNMENT'", + "'AT'", "'ATTRIBUTE'", "'BACKWARD'", "'BEFORE'", "'BEGIN'", + "'BY'", "'CACHE'", "'CALLED'", "'CASCADE'", "'CASCADED'", + "'CATALOG'", "'CHAIN'", "'CHARACTERISTICS'", "'CHECKPOINT'", + "'CLASS'", "'CLOSE'", "'CLUSTER'", "'COMMENT'", "'COMMENTS'", + "'COMMIT'", "'COMMITTED'", "'CONFIGURATION'", "'CONNECTION'", + "'CONSTRAINTS'", "'CONTENT'", "'CONTINUE'", "'CONVERSION'", + "'COPY'", "'COST'", "'CSV'", "'CURSOR'", "'CYCLE'", + "'DATA'", "'DATABASE'", "'DAY'", "'DEALLOCATE'", "'DECLARE'", + "'DEFAULTS'", "'DEFERRED'", "'DEFINER'", "'DELETE'", + "'DELIMITER'", "'DELIMITERS'", "'DICTIONARY'", "'DISABLE'", + "'DISCARD'", "'DOCUMENT'", "'DOMAIN'", "'DOUBLE'", + "'DROP'", "'EACH'", "'ENABLE'", "'ENCODING'", "'ENCRYPTED'", + "'ENUM'", "'ESCAPE'", "'EVENT'", "'EXCLUDE'", "'EXCLUDING'", + "'EXCLUSIVE'", "'EXECUTE'", "'EXPLAIN'", "'EXTENSION'", + "'EXTERNAL'", "'FAMILY'", "'FIRST'", "'FOLLOWING'", + "'FORCE'", "'FORWARD'", "'FUNCTION'", "'FUNCTIONS'", + "'GLOBAL'", "'GRANTED'", "'HANDLER'", "'HEADER'", "'HOLD'", + "'HOUR'", "'IDENTITY'", "'IF'", "'IMMEDIATE'", "'IMMUTABLE'", + "'IMPLICIT'", "'INCLUDING'", "'INCREMENT'", "'INDEX'", + "'INDEXES'", "'INHERIT'", "'INHERITS'", "'INLINE'", + "'INSENSITIVE'", "'INSERT'", "'INSTEAD'", "'INVOKER'", + "'ISOLATION'", "'KEY'", "'LABEL'", "'LANGUAGE'", "'LARGE'", + "'LAST'", "'LEAKPROOF'", "'LEVEL'", "'LISTEN'", "'LOAD'", + "'LOCAL'", "'LOCATION'", "'LOCK'", "'MAPPING'", "'MATCH'", + "'MATERIALIZED'", "'MAXVALUE'", "'MINUTE'", "'MINVALUE'", + "'MODE'", "'MONTH'", "'MOVE'", "'NAME'", "'NAMES'", + "'NEXT'", "'NO'", "'NOTHING'", "'NOTIFY'", "'NOWAIT'", + "'NULLS'", "'OBJECT'", "'OF'", "'OFF'", "'OIDS'", "'OPERATOR'", + "'OPTION'", "'OPTIONS'", "'OWNED'", "'OWNER'", "'PARSER'", + "'PARTIAL'", "'PARTITION'", "'PASSING'", "'PASSWORD'", + "'PLANS'", "'PRECEDING'", "'PREPARE'", "'PREPARED'", + "'PRESERVE'", "'PRIOR'", "'PRIVILEGES'", "'PROCEDURAL'", + "'PROCEDURE'", "'PROGRAM'", "'QUOTE'", "'RANGE'", "'READ'", + "'REASSIGN'", "'RECHECK'", "'RECURSIVE'", "'REF'", + "'REFRESH'", "'REINDEX'", "'RELATIVE'", "'RELEASE'", + "'RENAME'", "'REPEATABLE'", "'REPLACE'", "'REPLICA'", + "'RESET'", "'RESTART'", "'RESTRICT'", "'RETURNS'", + "'REVOKE'", "'ROLE'", "'ROLLBACK'", "'ROWS'", "'RULE'", + "'SAVEPOINT'", "'SCHEMA'", "'SCROLL'", "'SEARCH'", + "'SECOND'", "'SECURITY'", "'SEQUENCE'", "'SEQUENCES'", + "'SERIALIZABLE'", "'SERVER'", "'SESSION'", "'SET'", + "'SHARE'", "'SHOW'", "'SIMPLE'", "'SNAPSHOT'", "'STABLE'", + "'STANDALONE'", "'START'", "'STATEMENT'", "'STATISTICS'", + "'STDIN'", "'STDOUT'", "'STORAGE'", "'STRICT'", "'STRIP'", + "'SYSID'", "'SYSTEM'", "'TABLES'", "'TABLESPACE'", + "'TEMP'", "'TEMPLATE'", "'TEMPORARY'", "'TEXT'", "'TRANSACTION'", + "'TRIGGER'", "'TRUNCATE'", "'TRUSTED'", "'TYPE'", "'TYPES'", + "'UNBOUNDED'", "'UNCOMMITTED'", "'UNENCRYPTED'", "'UNKNOWN'", + "'UNLISTEN'", "'UNLOGGED'", "'UNTIL'", "'UPDATE'", + "'VACUUM'", "'VALID'", "'VALIDATE'", "'VALIDATOR'", + "'VARYING'", "'VERSION'", "'VIEW'", "'VOLATILE'", "'WHITESPACE'", + "'WITHOUT'", "'WORK'", "'WRAPPER'", "'WRITE'", "'XML'", + "'YEAR'", "'YES'", "'ZONE'", "'BETWEEN'", "'BIGINT'", + "'BIT'", "'BOOLEAN'", "'CHAR'", "'CHARACTER'", "'COALESCE'", + "'DEC'", "'DECIMAL'", "'EXISTS'", "'EXTRACT'", "'FLOAT'", + "'GREATEST'", "'INOUT'", "'INT'", "'INTEGER'", "'INTERVAL'", + "'LEAST'", "'NATIONAL'", "'NCHAR'", "'NONE'", "'NULLIF'", + "'NUMERIC'", "'OVERLAY'", "'POSITION'", "'PRECISION'", + "'REAL'", "'ROW'", "'SETOF'", "'SMALLINT'", "'SUBSTRING'", + "'TIME'", "'TIMESTAMP'", "'TREAT'", "'TRIM'", "'VALUES'", + "'VARCHAR'", "'XMLATTRIBUTES'", "'XMLCONCAT'", "'XMLELEMENT'", + "'XMLEXISTS'", "'XMLFOREST'", "'XMLPARSE'", "'XMLPI'", + "'XMLROOT'", "'XMLSERIALIZE'", "'CALL'", "'CURRENT'", + "'ATTACH'", "'DETACH'", "'EXPRESSION'", "'GENERATED'", + "'LOGGED'", "'STORED'", "'INCLUDE'", "'ROUTINE'", "'TRANSFORM'", + "'IMPORT'", "'POLICY'", "'METHOD'", "'REFERENCING'", + "'NEW'", "'OLD'", "'VALUE'", "'SUBSCRIPTION'", "'PUBLICATION'", + "'OUT'", "'END'", "'ROUTINES'", "'SCHEMAS'", "'PROCEDURES'", + "'INPUT'", "'SUPPORT'", "'PARALLEL'", "'SQL'", "'DEPENDS'", + "'OVERRIDING'", "'CONFLICT'", "'SKIP'", "'LOCKED'", + "'TIES'", "'ROLLUP'", "'CUBE'", "'GROUPING'", "'SETS'", + "'TABLESAMPLE'", "'ORDINALITY'", "'XMLTABLE'", "'COLUMNS'", + "'XMLNAMESPACES'", "'ROWTYPE'", "'NORMALIZED'", "'WITHIN'", + "'FILTER'", "'GROUPS'", "'OTHERS'", "'NFC'", "'NFD'", + "'NFKC'", "'NFKD'", "'UESCAPE'", "'VIEWS'", "'NORMALIZE'", + "'DUMP'", "'PRINT_STRICT_PARAMS'", "'VARIABLE_CONFLICT'", + "'ERROR'", "'USE_VARIABLE'", "'USE_COLUMN'", "'ALIAS'", + "'CONSTANT'", "'PERFORM'", "'GET'", "'DIAGNOSTICS'", + "'STACKED'", "'ELSIF'", "'WHILE'", "'REVERSE'", "'FOREACH'", + "'SLICE'", "'EXIT'", "'RETURN'", "'QUERY'", "'RAISE'", + "'SQLSTATE'", "'DEBUG'", "'LOG'", "'INFO'", "'NOTICE'", + "'WARNING'", "'EXCEPTION'", "'ASSERT'", "'LOOP'", "'OPEN'", + null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, null, null, null, + null, null, null, null, null, null, "'\\\\'", null, + null, null, null, null, null, null, null, null, "'''" ]; + +var symbolicNames = [ null, "Dollar", "OPEN_PAREN", "CLOSE_PAREN", "OPEN_BRACKET", + "CLOSE_BRACKET", "COMMA", "SEMI", "COLON", "STAR", + "EQUAL", "DOT", "PLUS", "MINUS", "SLASH", "CARET", + "LT", "GT", "LESS_LESS", "GREATER_GREATER", "COLON_EQUALS", + "LESS_EQUALS", "EQUALS_GREATER", "GREATER_EQUALS", + "DOT_DOT", "NOT_EQUALS", "TYPECAST", "PERCENT", "PARAM", + "Operator", "ALL", "ANALYSE", "ANALYZE", "AND", "ANY", + "ARRAY", "AS", "ASC", "ASYMMETRIC", "BOTH", "CASE", + "CAST", "CHECK", "COLLATE", "COLUMN", "CONSTRAINT", + "CREATE", "CURRENT_CATALOG", "CURRENT_DATE", "CURRENT_ROLE", + "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", + "DEFAULT", "DEFERRABLE", "DESC", "DISTINCT", "DO", + "ELSE", "EXCEPT", "FALSE_P", "FETCH", "FOR", "FOREIGN", + "FROM", "GRANT", "GROUP_P", "HAVING", "IN_P", "INITIALLY", + "INTERSECT", "INTO", "LATERAL_P", "LEADING", "LIMIT", + "LOCALTIME", "LOCALTIMESTAMP", "NOT", "NULL_P", "OFFSET", + "ON", "ONLY", "OR", "ORDER", "PLACING", "PRIMARY", + "REFERENCES", "RETURNING", "SELECT", "SESSION_USER", + "SOME", "SYMMETRIC", "TABLE", "THEN", "TO", "TRAILING", + "TRUE_P", "UNION", "UNIQUE", "USER", "USING", "VARIADIC", + "WHEN", "WHERE", "WINDOW", "WITH", "AUTHORIZATION", + "BINARY", "COLLATION", "CONCURRENTLY", "CROSS", "CURRENT_SCHEMA", + "FREEZE", "FULL", "ILIKE", "INNER_P", "IS", "ISNULL", + "JOIN", "LEFT", "LIKE", "NATURAL", "NOTNULL", "OUTER_P", + "OVER", "OVERLAPS", "RIGHT", "SIMILAR", "VERBOSE", + "ABORT_P", "ABSOLUTE_P", "ACCESS", "ACTION", "ADD_P", + "ADMIN", "AFTER", "AGGREGATE", "ALSO", "ALTER", "ALWAYS", + "ASSERTION", "ASSIGNMENT", "AT", "ATTRIBUTE", "BACKWARD", + "BEFORE", "BEGIN_P", "BY", "CACHE", "CALLED", "CASCADE", + "CASCADED", "CATALOG", "CHAIN", "CHARACTERISTICS", + "CHECKPOINT", "CLASS", "CLOSE", "CLUSTER", "COMMENT", + "COMMENTS", "COMMIT", "COMMITTED", "CONFIGURATION", + "CONNECTION", "CONSTRAINTS", "CONTENT_P", "CONTINUE_P", + "CONVERSION_P", "COPY", "COST", "CSV", "CURSOR", "CYCLE", + "DATA_P", "DATABASE", "DAY_P", "DEALLOCATE", "DECLARE", + "DEFAULTS", "DEFERRED", "DEFINER", "DELETE_P", "DELIMITER", + "DELIMITERS", "DICTIONARY", "DISABLE_P", "DISCARD", + "DOCUMENT_P", "DOMAIN_P", "DOUBLE_P", "DROP", "EACH", + "ENABLE_P", "ENCODING", "ENCRYPTED", "ENUM_P", "ESCAPE", + "EVENT", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", + "EXPLAIN", "EXTENSION", "EXTERNAL", "FAMILY", "FIRST_P", + "FOLLOWING", "FORCE", "FORWARD", "FUNCTION", "FUNCTIONS", + "GLOBAL", "GRANTED", "HANDLER", "HEADER_P", "HOLD", + "HOUR_P", "IDENTITY_P", "IF_P", "IMMEDIATE", "IMMUTABLE", + "IMPLICIT_P", "INCLUDING", "INCREMENT", "INDEX", "INDEXES", + "INHERIT", "INHERITS", "INLINE_P", "INSENSITIVE", + "INSERT", "INSTEAD", "INVOKER", "ISOLATION", "KEY", + "LABEL", "LANGUAGE", "LARGE_P", "LAST_P", "LEAKPROOF", + "LEVEL", "LISTEN", "LOAD", "LOCAL", "LOCATION", "LOCK_P", + "MAPPING", "MATCH", "MATERIALIZED", "MAXVALUE", "MINUTE_P", + "MINVALUE", "MODE", "MONTH_P", "MOVE", "NAME_P", "NAMES", + "NEXT", "NO", "NOTHING", "NOTIFY", "NOWAIT", "NULLS_P", + "OBJECT_P", "OF", "OFF", "OIDS", "OPERATOR", "OPTION", + "OPTIONS", "OWNED", "OWNER", "PARSER", "PARTIAL", + "PARTITION", "PASSING", "PASSWORD", "PLANS", "PRECEDING", + "PREPARE", "PREPARED", "PRESERVE", "PRIOR", "PRIVILEGES", + "PROCEDURAL", "PROCEDURE", "PROGRAM", "QUOTE", "RANGE", + "READ", "REASSIGN", "RECHECK", "RECURSIVE", "REF", + "REFRESH", "REINDEX", "RELATIVE_P", "RELEASE", "RENAME", + "REPEATABLE", "REPLACE", "REPLICA", "RESET", "RESTART", + "RESTRICT", "RETURNS", "REVOKE", "ROLE", "ROLLBACK", + "ROWS", "RULE", "SAVEPOINT", "SCHEMA", "SCROLL", "SEARCH", + "SECOND_P", "SECURITY", "SEQUENCE", "SEQUENCES", "SERIALIZABLE", + "SERVER", "SESSION", "SET", "SHARE", "SHOW", "SIMPLE", + "SNAPSHOT", "STABLE", "STANDALONE_P", "START", "STATEMENT", + "STATISTICS", "STDIN", "STDOUT", "STORAGE", "STRICT_P", + "STRIP_P", "SYSID", "SYSTEM_P", "TABLES", "TABLESPACE", + "TEMP", "TEMPLATE", "TEMPORARY", "TEXT_P", "TRANSACTION", + "TRIGGER", "TRUNCATE", "TRUSTED", "TYPE_P", "TYPES_P", + "UNBOUNDED", "UNCOMMITTED", "UNENCRYPTED", "UNKNOWN", + "UNLISTEN", "UNLOGGED", "UNTIL", "UPDATE", "VACUUM", + "VALID", "VALIDATE", "VALIDATOR", "VARYING", "VERSION_P", + "VIEW", "VOLATILE", "WHITESPACE_P", "WITHOUT", "WORK", + "WRAPPER", "WRITE", "XML_P", "YEAR_P", "YES_P", "ZONE", + "BETWEEN", "BIGINT", "BIT", "BOOLEAN_P", "CHAR_P", + "CHARACTER", "COALESCE", "DEC", "DECIMAL_P", "EXISTS", + "EXTRACT", "FLOAT_P", "GREATEST", "INOUT", "INT_P", + "INTEGER", "INTERVAL", "LEAST", "NATIONAL", "NCHAR", + "NONE", "NULLIF", "NUMERIC", "OVERLAY", "POSITION", + "PRECISION", "REAL", "ROW", "SETOF", "SMALLINT", "SUBSTRING", + "TIME", "TIMESTAMP", "TREAT", "TRIM", "VALUES", "VARCHAR", + "XMLATTRIBUTES", "XMLCONCAT", "XMLELEMENT", "XMLEXISTS", + "XMLFOREST", "XMLPARSE", "XMLPI", "XMLROOT", "XMLSERIALIZE", + "CALL", "CURRENT_P", "ATTACH", "DETACH", "EXPRESSION", + "GENERATED", "LOGGED", "STORED", "INCLUDE", "ROUTINE", + "TRANSFORM", "IMPORT_P", "POLICY", "METHOD", "REFERENCING", + "NEW", "OLD", "VALUE_P", "SUBSCRIPTION", "PUBLICATION", + "OUT_P", "END_P", "ROUTINES", "SCHEMAS", "PROCEDURES", + "INPUT_P", "SUPPORT", "PARALLEL", "SQL_P", "DEPENDS", + "OVERRIDING", "CONFLICT", "SKIP_P", "LOCKED", "TIES", + "ROLLUP", "CUBE", "GROUPING", "SETS", "TABLESAMPLE", + "ORDINALITY", "XMLTABLE", "COLUMNS", "XMLNAMESPACES", + "ROWTYPE", "NORMALIZED", "WITHIN", "FILTER", "GROUPS", + "OTHERS", "NFC", "NFD", "NFKC", "NFKD", "UESCAPE", + "VIEWS", "NORMALIZE", "DUMP", "PRINT_STRICT_PARAMS", + "VARIABLE_CONFLICT", "ERROR", "USE_VARIABLE", "USE_COLUMN", + "ALIAS", "CONSTANT", "PERFORM", "GET", "DIAGNOSTICS", + "STACKED", "ELSIF", "WHILE", "REVERSE", "FOREACH", + "SLICE", "EXIT", "RETURN", "QUERY", "RAISE", "SQLSTATE", + "DEBUG", "LOG", "INFO", "NOTICE", "WARNING", "EXCEPTION", + "ASSERT", "LOOP", "OPEN", "Identifier", "QuotedIdentifier", + "UnterminatedQuotedIdentifier", "InvalidQuotedIdentifier", + "InvalidUnterminatedQuotedIdentifier", "UnicodeQuotedIdentifier", + "UnterminatedUnicodeQuotedIdentifier", "InvalidUnicodeQuotedIdentifier", + "InvalidUnterminatedUnicodeQuotedIdentifier", "StringConstant", + "UnterminatedStringConstant", "UnicodeEscapeStringConstant", + "UnterminatedUnicodeEscapeStringConstant", "BeginDollarStringConstant", + "BinaryStringConstant", "UnterminatedBinaryStringConstant", + "InvalidBinaryStringConstant", "InvalidUnterminatedBinaryStringConstant", + "HexadecimalStringConstant", "UnterminatedHexadecimalStringConstant", + "InvalidHexadecimalStringConstant", "InvalidUnterminatedHexadecimalStringConstant", + "Integral", "NumericFail", "Numeric", "PLSQLVARIABLENAME", + "PLSQLIDENTIFIER", "Whitespace", "Newline", "LineComment", + "BlockComment", "UnterminatedBlockComment", "MetaCommand", + "EndMetaCommand", "ErrorCharacter", "EscapeStringConstant", + "UnterminatedEscapeStringConstant", "InvalidEscapeStringConstant", + "InvalidUnterminatedEscapeStringConstant", "AfterEscapeStringConstantMode_NotContinued", + "AfterEscapeStringConstantWithNewlineMode_NotContinued", + "DollarText", "EndDollarStringConstant", "AfterEscapeStringConstantWithNewlineMode_Continued" ]; + +var ruleNames = [ "root", "plsqlroot", "stmtblock", "stmtmulti", "stmt", + "plsqlconsolecommand", "callstmt", "createrolestmt", + "opt_with", "optrolelist", "alteroptrolelist", "alteroptroleelem", + "createoptroleelem", "createuserstmt", "alterrolestmt", + "opt_in_database", "alterrolesetstmt", "droprolestmt", + "creategroupstmt", "altergroupstmt", "add_drop", "createschemastmt", + "optschemaname", "optschemaeltlist", "schema_stmt", "variablesetstmt", + "set_rest", "generic_set", "set_rest_more", "var_name", + "var_list", "var_value", "iso_level", "opt_boolean_or_string", + "zone_value", "opt_encoding", "nonreservedword_or_sconst", + "variableresetstmt", "reset_rest", "generic_reset", "setresetclause", + "functionsetresetclause", "variableshowstmt", "constraintssetstmt", + "constraints_set_list", "constraints_set_mode", "checkpointstmt", + "discardstmt", "altertablestmt", "alter_table_cmds", + "partition_cmd", "index_partition_cmd", "alter_table_cmd", + "alter_column_default", "opt_drop_behavior", "opt_collate_clause", + "alter_using", "replica_identity", "reloptions", "opt_reloptions", + "reloption_list", "reloption_elem", "alter_identity_column_option_list", + "alter_identity_column_option", "partitionboundspec", + "hash_partbound_elem", "hash_partbound", "altercompositetypestmt", + "alter_type_cmds", "alter_type_cmd", "closeportalstmt", + "copystmt", "copy_from", "opt_program", "copy_file_name", + "copy_options", "copy_opt_list", "copy_opt_item", "opt_binary", + "copy_delimiter", "opt_using", "copy_generic_opt_list", + "copy_generic_opt_elem", "copy_generic_opt_arg", "copy_generic_opt_arg_list", + "copy_generic_opt_arg_list_item", "createstmt", "opttemp", + "opttableelementlist", "opttypedtableelementlist", "tableelementlist", + "typedtableelementlist", "tableelement", "typedtableelement", + "columnDef", "columnOptions", "colquallist", "colconstraint", + "colconstraintelem", "generated_when", "constraintattr", + "tablelikeclause", "tablelikeoptionlist", "tablelikeoption", + "tableconstraint", "constraintelem", "opt_no_inherit", + "opt_column_list", "columnlist", "columnElem", "opt_c_include", + "key_match", "exclusionconstraintlist", "exclusionconstraintelem", + "exclusionwhereclause", "key_actions", "key_update", + "key_delete", "key_action", "optinherit", "optpartitionspec", + "partitionspec", "part_params", "part_elem", "table_access_method_clause", + "optwith", "oncommitoption", "opttablespace", "optconstablespace", + "existingindex", "createstatsstmt", "alterstatsstmt", + "createasstmt", "create_as_target", "opt_with_data", + "creatematviewstmt", "create_mv_target", "optnolog", + "refreshmatviewstmt", "createseqstmt", "alterseqstmt", + "optseqoptlist", "optparenthesizedseqoptlist", "seqoptlist", + "seqoptelem", "opt_by", "numericonly", "numericonly_list", + "createplangstmt", "opt_trusted", "handler_name", "opt_inline_handler", + "validator_clause", "opt_validator", "opt_procedural", + "createtablespacestmt", "opttablespaceowner", "droptablespacestmt", + "createextensionstmt", "create_extension_opt_list", "create_extension_opt_item", + "alterextensionstmt", "alter_extension_opt_list", "alter_extension_opt_item", + "alterextensioncontentsstmt", "createfdwstmt", "fdw_option", + "fdw_options", "opt_fdw_options", "alterfdwstmt", "create_generic_options", + "generic_option_list", "alter_generic_options", "alter_generic_option_list", + "alter_generic_option_elem", "generic_option_elem", "generic_option_name", + "generic_option_arg", "createforeignserverstmt", "opt_type", + "foreign_server_version", "opt_foreign_server_version", + "alterforeignserverstmt", "createforeigntablestmt", "importforeignschemastmt", + "import_qualification_type", "import_qualification", + "createusermappingstmt", "auth_ident", "dropusermappingstmt", + "alterusermappingstmt", "createpolicystmt", "alterpolicystmt", + "rowsecurityoptionalexpr", "rowsecurityoptionalwithcheck", + "rowsecuritydefaulttorole", "rowsecurityoptionaltorole", + "rowsecuritydefaultpermissive", "rowsecuritydefaultforcmd", + "row_security_cmd", "createamstmt", "am_type", "createtrigstmt", + "triggeractiontime", "triggerevents", "triggeroneevent", + "triggerreferencing", "triggertransitions", "triggertransition", + "transitionoldornew", "transitionrowortable", "transitionrelname", + "triggerforspec", "triggerforopteach", "triggerfortype", + "triggerwhen", "function_or_procedure", "triggerfuncargs", + "triggerfuncarg", "optconstrfromtable", "constraintattributespec", + "constraintattributeElem", "createeventtrigstmt", "event_trigger_when_list", + "event_trigger_when_item", "event_trigger_value_list", + "altereventtrigstmt", "enable_trigger", "createassertionstmt", + "definestmt", "definition", "def_list", "def_elem", "def_arg", + "old_aggr_definition", "old_aggr_list", "old_aggr_elem", + "opt_enum_val_list", "enum_val_list", "alterenumstmt", + "opt_if_not_exists", "createopclassstmt", "opclass_item_list", + "opclass_item", "opt_default", "opt_opfamily", "opclass_purpose", + "opt_recheck", "createopfamilystmt", "alteropfamilystmt", + "opclass_drop_list", "opclass_drop", "dropopclassstmt", + "dropopfamilystmt", "dropownedstmt", "reassignownedstmt", + "dropstmt", "object_type_any_name", "object_type_name", + "drop_type_name", "object_type_name_on_any_name", "any_name_list", + "any_name", "attrs", "type_name_list", "truncatestmt", + "opt_restart_seqs", "commentstmt", "comment_text", "seclabelstmt", + "opt_provider", "security_label", "fetchstmt", "fetch_args", + "from_in", "opt_from_in", "grantstmt", "revokestmt", + "privileges", "privilege_list", "privilege", "privilege_target", + "grantee_list", "grantee", "opt_grant_grant_option", + "grantrolestmt", "revokerolestmt", "opt_grant_admin_option", + "opt_granted_by", "alterdefaultprivilegesstmt", "defacloptionlist", + "defacloption", "defaclaction", "defacl_privilege_target", + "indexstmt", "opt_unique", "opt_concurrently", "opt_index_name", + "access_method_clause", "index_params", "index_elem_options", + "index_elem", "opt_include", "index_including_params", + "opt_collate", "opt_class", "opt_asc_desc", "opt_nulls_order", + "createfunctionstmt", "opt_or_replace", "func_args", + "func_args_list", "function_with_argtypes_list", "function_with_argtypes", + "func_args_with_defaults", "func_args_with_defaults_list", + "func_arg", "arg_class", "param_name", "func_return", + "func_type", "func_arg_with_default", "aggr_arg", "aggr_args", + "aggr_args_list", "aggregate_with_argtypes", "aggregate_with_argtypes_list", + "createfunc_opt_list", "common_func_opt_item", "createfunc_opt_item", + "func_as", "transform_type_list", "opt_definition", "table_func_column", + "table_func_column_list", "alterfunctionstmt", "alterfunc_opt_list", + "opt_restrict", "removefuncstmt", "removeaggrstmt", "removeoperstmt", + "oper_argtypes", "any_operator", "operator_with_argtypes_list", + "operator_with_argtypes", "dostmt", "dostmt_opt_list", + "dostmt_opt_item", "createcaststmt", "cast_context", + "dropcaststmt", "opt_if_exists", "createtransformstmt", + "transform_element_list", "droptransformstmt", "reindexstmt", + "reindex_target_type", "reindex_target_multitable", "reindex_option_list", + "reindex_option_elem", "altertblspcstmt", "renamestmt", + "opt_column", "opt_set_data", "alterobjectdependsstmt", + "opt_no", "alterobjectschemastmt", "alteroperatorstmt", + "operator_def_list", "operator_def_elem", "operator_def_arg", + "altertypestmt", "alterownerstmt", "createpublicationstmt", + "opt_publication_for_tables", "publication_for_tables", + "alterpublicationstmt", "createsubscriptionstmt", "publication_name_list", + "publication_name_item", "altersubscriptionstmt", "dropsubscriptionstmt", + "rulestmt", "ruleactionlist", "ruleactionmulti", "ruleactionstmt", + "ruleactionstmtOrEmpty", "event", "opt_instead", "notifystmt", + "notify_payload", "listenstmt", "unlistenstmt", "transactionstmt", + "opt_transaction", "transaction_mode_item", "transaction_mode_list", + "transaction_mode_list_or_empty", "opt_transaction_chain", + "viewstmt", "opt_check_option", "loadstmt", "createdbstmt", + "createdb_opt_list", "createdb_opt_items", "createdb_opt_item", + "createdb_opt_name", "opt_equal", "alterdatabasestmt", + "alterdatabasesetstmt", "dropdbstmt", "drop_option_list", + "drop_option", "altercollationstmt", "altersystemstmt", + "createdomainstmt", "alterdomainstmt", "opt_as", "altertsdictionarystmt", + "altertsconfigurationstmt", "any_with", "createconversionstmt", + "clusterstmt", "cluster_index_specification", "vacuumstmt", + "analyzestmt", "vac_analyze_option_list", "analyze_keyword", + "vac_analyze_option_elem", "vac_analyze_option_name", + "vac_analyze_option_arg", "opt_analyze", "opt_verbose", + "opt_full", "opt_freeze", "opt_name_list", "vacuum_relation", + "vacuum_relation_list", "opt_vacuum_relation_list", "explainstmt", + "explainablestmt", "explain_option_list", "explain_option_elem", + "explain_option_name", "explain_option_arg", "preparestmt", + "prep_type_clause", "preparablestmt", "executestmt", + "execute_param_clause", "deallocatestmt", "insertstmt", + "insert_target", "insert_rest", "override_kind", "insert_column_list", + "insert_column_item", "opt_on_conflict", "opt_conf_expr", + "returning_clause", "deletestmt", "using_clause", "lockstmt", + "opt_lock", "lock_type", "opt_nowait", "opt_nowait_or_skip", + "updatestmt", "set_clause_list", "set_clause", "set_target", + "set_target_list", "declarecursorstmt", "cursor_name", + "cursor_options", "opt_hold", "selectstmt", "select_with_parens", + "select_no_parens", "select_clause", "simple_select", + "set_operator", "set_operator_with_all_or_distinct", + "with_clause", "cte_list", "common_table_expr", "opt_materialized", + "opt_with_clause", "into_clause", "opt_strict", "opttempTableName", + "opt_table", "all_or_distinct", "distinct_clause", "opt_all_clause", + "opt_sort_clause", "sort_clause", "sortby_list", "sortby", + "select_limit", "opt_select_limit", "limit_clause", "offset_clause", + "select_limit_value", "select_offset_value", "select_fetch_first_value", + "i_or_f_const", "row_or_rows", "first_or_next", "group_clause", + "group_by_list", "group_by_item", "empty_grouping_set", + "rollup_clause", "cube_clause", "grouping_sets_clause", + "having_clause", "for_locking_clause", "opt_for_locking_clause", + "for_locking_items", "for_locking_item", "for_locking_strength", + "locked_rels_list", "values_clause", "from_clause", "from_list", + "table_ref", "alias_clause", "opt_alias_clause", "func_alias_clause", + "join_type", "join_qual", "relation_expr", "relation_expr_list", + "relation_expr_opt_alias", "tablesample_clause", "opt_repeatable_clause", + "func_table", "rowsfrom_item", "rowsfrom_list", "opt_col_def_list", + "opt_ordinality", "where_clause", "where_or_current_clause", + "opttablefuncelementlist", "tablefuncelementlist", "tablefuncelement", + "xmltable", "xmltable_column_list", "xmltable_column_el", + "xmltable_column_option_list", "xmltable_column_option_el", + "xml_namespace_list", "xml_namespace_el", "typename", + "opt_array_bounds", "simpletypename", "consttypename", + "generictype", "opt_type_modifiers", "numeric", "opt_float", + "bit", "constbit", "bitwithlength", "bitwithoutlength", + "character", "constcharacter", "character_c", "opt_varying", + "constdatetime", "constinterval", "opt_timezone", "opt_interval", + "interval_second", "opt_escape", "a_expr", "a_expr_qual", + "a_expr_lessless", "a_expr_or", "a_expr_and", "a_expr_in", + "a_expr_unary_not", "a_expr_isnull", "a_expr_is_not", + "a_expr_compare", "a_expr_like", "a_expr_qual_op", "a_expr_unary_qualop", + "a_expr_add", "a_expr_mul", "a_expr_caret", "a_expr_unary_sign", + "a_expr_at_time_zone", "a_expr_collate", "a_expr_typecast", + "b_expr", "c_expr", "plsqlvariablename", "func_application", + "func_expr", "func_expr_windowless", "func_expr_common_subexpr", + "xml_root_version", "opt_xml_root_standalone", "xml_attributes", + "xml_attribute_list", "xml_attribute_el", "document_or_content", + "xml_whitespace_option", "xmlexists_argument", "xml_passing_mech", + "within_group_clause", "filter_clause", "window_clause", + "window_definition_list", "window_definition", "over_clause", + "window_specification", "opt_existing_window_name", "opt_partition_clause", + "opt_frame_clause", "frame_extent", "frame_bound", "opt_window_exclusion_clause", + "row", "explicit_row", "implicit_row", "sub_type", "all_op", + "mathop", "qual_op", "qual_all_op", "subquery_Op", "expr_list", + "func_arg_list", "func_arg_expr", "type_list", "array_expr", + "array_expr_list", "extract_list", "extract_arg", "unicode_normal_form", + "overlay_list", "position_list", "substr_list", "trim_list", + "in_expr", "case_expr", "when_clause_list", "when_clause", + "case_default", "case_arg", "columnref", "indirection_el", + "opt_slice_bound", "indirection", "opt_indirection", + "opt_target_list", "target_list", "target_el", "qualified_name_list", + "qualified_name", "name_list", "name", "attr_name", "file_name", + "func_name", "aexprconst", "xconst", "bconst", "fconst", + "iconst", "sconst", "anysconst", "opt_uescape", "signediconst", + "roleid", "rolespec", "role_list", "colid", "type_function_name", + "nonreservedword", "collabel", "identifier", "plsqlidentifier", + "unreserved_keyword", "col_name_keyword", "type_func_name_keyword", + "reserved_keyword", "pl_function", "comp_options", "comp_option", + "sharp", "option_value", "opt_semi", "pl_block", "decl_sect", + "decl_start", "decl_stmts", "label_decl", "decl_stmt", + "decl_statement", "opt_scrollable", "decl_cursor_query", + "decl_cursor_args", "decl_cursor_arglist", "decl_cursor_arg", + "decl_is_for", "decl_aliasitem", "decl_varname", "decl_const", + "decl_datatype", "decl_collate", "decl_notnull", "decl_defval", + "decl_defkey", "assign_operator", "proc_sect", "proc_stmt", + "stmt_perform", "stmt_call", "opt_expr_list", "stmt_assign", + "stmt_getdiag", "getdiag_area_opt", "getdiag_list", "getdiag_list_item", + "getdiag_item", "getdiag_target", "assign_var", "stmt_if", + "stmt_elsifs", "stmt_else", "stmt_case", "opt_expr_until_when", + "case_when_list", "case_when", "opt_case_else", "stmt_loop", + "stmt_while", "stmt_for", "for_control", "opt_for_using_expression", + "opt_cursor_parameters", "opt_reverse", "opt_by_expression", + "for_variable", "stmt_foreach_a", "foreach_slice", "stmt_exit", + "exit_type", "stmt_return", "opt_return_result", "stmt_raise", + "opt_stmt_raise_level", "opt_raise_list", "opt_raise_using", + "opt_raise_using_elem", "opt_raise_using_elem_list", + "stmt_assert", "opt_stmt_assert_message", "loop_body", + "stmt_execsql", "stmt_dynexecute", "opt_execute_using", + "opt_execute_using_list", "opt_execute_into", "stmt_open", + "opt_open_bound_list_item", "opt_open_bound_list", "opt_open_using", + "opt_scroll_option", "opt_scroll_option_no", "stmt_fetch", + "into_target", "opt_cursor_from", "opt_fetch_direction", + "stmt_move", "stmt_close", "stmt_null", "stmt_commit", + "stmt_rollback", "plsql_opt_transaction_chain", "stmt_set", + "cursor_variable", "exception_sect", "proc_exceptions", + "proc_exception", "proc_conditions", "proc_condition", + "opt_block_label", "opt_loop_label", "opt_label", "opt_exitcond", + "any_identifier", "plsql_unreserved_keyword", "sql_expression", + "expr_until_then", "expr_until_semi", "expr_until_rightbracket", + "expr_until_loop", "make_execsql_stmt", "opt_returning_clause_into" ]; + +function PostgreSQLParser (input) { + PostgreSQLParserBase.call(this, input); + this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache); + this.ruleNames = ruleNames; + this.literalNames = literalNames; + this.symbolicNames = symbolicNames; + + + return this; +} + +PostgreSQLParser.prototype = Object.create(PostgreSQLParserBase.prototype); +PostgreSQLParser.prototype.constructor = PostgreSQLParser; + +Object.defineProperty(PostgreSQLParser.prototype, "atn", { + get : function() { + return atn; + } +}); + +PostgreSQLParser.EOF = antlr4.Token.EOF; +PostgreSQLParser.Dollar = 1; +PostgreSQLParser.OPEN_PAREN = 2; +PostgreSQLParser.CLOSE_PAREN = 3; +PostgreSQLParser.OPEN_BRACKET = 4; +PostgreSQLParser.CLOSE_BRACKET = 5; +PostgreSQLParser.COMMA = 6; +PostgreSQLParser.SEMI = 7; +PostgreSQLParser.COLON = 8; +PostgreSQLParser.STAR = 9; +PostgreSQLParser.EQUAL = 10; +PostgreSQLParser.DOT = 11; +PostgreSQLParser.PLUS = 12; +PostgreSQLParser.MINUS = 13; +PostgreSQLParser.SLASH = 14; +PostgreSQLParser.CARET = 15; +PostgreSQLParser.LT = 16; +PostgreSQLParser.GT = 17; +PostgreSQLParser.LESS_LESS = 18; +PostgreSQLParser.GREATER_GREATER = 19; +PostgreSQLParser.COLON_EQUALS = 20; +PostgreSQLParser.LESS_EQUALS = 21; +PostgreSQLParser.EQUALS_GREATER = 22; +PostgreSQLParser.GREATER_EQUALS = 23; +PostgreSQLParser.DOT_DOT = 24; +PostgreSQLParser.NOT_EQUALS = 25; +PostgreSQLParser.TYPECAST = 26; +PostgreSQLParser.PERCENT = 27; +PostgreSQLParser.PARAM = 28; +PostgreSQLParser.Operator = 29; +PostgreSQLParser.ALL = 30; +PostgreSQLParser.ANALYSE = 31; +PostgreSQLParser.ANALYZE = 32; +PostgreSQLParser.AND = 33; +PostgreSQLParser.ANY = 34; +PostgreSQLParser.ARRAY = 35; +PostgreSQLParser.AS = 36; +PostgreSQLParser.ASC = 37; +PostgreSQLParser.ASYMMETRIC = 38; +PostgreSQLParser.BOTH = 39; +PostgreSQLParser.CASE = 40; +PostgreSQLParser.CAST = 41; +PostgreSQLParser.CHECK = 42; +PostgreSQLParser.COLLATE = 43; +PostgreSQLParser.COLUMN = 44; +PostgreSQLParser.CONSTRAINT = 45; +PostgreSQLParser.CREATE = 46; +PostgreSQLParser.CURRENT_CATALOG = 47; +PostgreSQLParser.CURRENT_DATE = 48; +PostgreSQLParser.CURRENT_ROLE = 49; +PostgreSQLParser.CURRENT_TIME = 50; +PostgreSQLParser.CURRENT_TIMESTAMP = 51; +PostgreSQLParser.CURRENT_USER = 52; +PostgreSQLParser.DEFAULT = 53; +PostgreSQLParser.DEFERRABLE = 54; +PostgreSQLParser.DESC = 55; +PostgreSQLParser.DISTINCT = 56; +PostgreSQLParser.DO = 57; +PostgreSQLParser.ELSE = 58; +PostgreSQLParser.EXCEPT = 59; +PostgreSQLParser.FALSE_P = 60; +PostgreSQLParser.FETCH = 61; +PostgreSQLParser.FOR = 62; +PostgreSQLParser.FOREIGN = 63; +PostgreSQLParser.FROM = 64; +PostgreSQLParser.GRANT = 65; +PostgreSQLParser.GROUP_P = 66; +PostgreSQLParser.HAVING = 67; +PostgreSQLParser.IN_P = 68; +PostgreSQLParser.INITIALLY = 69; +PostgreSQLParser.INTERSECT = 70; +PostgreSQLParser.INTO = 71; +PostgreSQLParser.LATERAL_P = 72; +PostgreSQLParser.LEADING = 73; +PostgreSQLParser.LIMIT = 74; +PostgreSQLParser.LOCALTIME = 75; +PostgreSQLParser.LOCALTIMESTAMP = 76; +PostgreSQLParser.NOT = 77; +PostgreSQLParser.NULL_P = 78; +PostgreSQLParser.OFFSET = 79; +PostgreSQLParser.ON = 80; +PostgreSQLParser.ONLY = 81; +PostgreSQLParser.OR = 82; +PostgreSQLParser.ORDER = 83; +PostgreSQLParser.PLACING = 84; +PostgreSQLParser.PRIMARY = 85; +PostgreSQLParser.REFERENCES = 86; +PostgreSQLParser.RETURNING = 87; +PostgreSQLParser.SELECT = 88; +PostgreSQLParser.SESSION_USER = 89; +PostgreSQLParser.SOME = 90; +PostgreSQLParser.SYMMETRIC = 91; +PostgreSQLParser.TABLE = 92; +PostgreSQLParser.THEN = 93; +PostgreSQLParser.TO = 94; +PostgreSQLParser.TRAILING = 95; +PostgreSQLParser.TRUE_P = 96; +PostgreSQLParser.UNION = 97; +PostgreSQLParser.UNIQUE = 98; +PostgreSQLParser.USER = 99; +PostgreSQLParser.USING = 100; +PostgreSQLParser.VARIADIC = 101; +PostgreSQLParser.WHEN = 102; +PostgreSQLParser.WHERE = 103; +PostgreSQLParser.WINDOW = 104; +PostgreSQLParser.WITH = 105; +PostgreSQLParser.AUTHORIZATION = 106; +PostgreSQLParser.BINARY = 107; +PostgreSQLParser.COLLATION = 108; +PostgreSQLParser.CONCURRENTLY = 109; +PostgreSQLParser.CROSS = 110; +PostgreSQLParser.CURRENT_SCHEMA = 111; +PostgreSQLParser.FREEZE = 112; +PostgreSQLParser.FULL = 113; +PostgreSQLParser.ILIKE = 114; +PostgreSQLParser.INNER_P = 115; +PostgreSQLParser.IS = 116; +PostgreSQLParser.ISNULL = 117; +PostgreSQLParser.JOIN = 118; +PostgreSQLParser.LEFT = 119; +PostgreSQLParser.LIKE = 120; +PostgreSQLParser.NATURAL = 121; +PostgreSQLParser.NOTNULL = 122; +PostgreSQLParser.OUTER_P = 123; +PostgreSQLParser.OVER = 124; +PostgreSQLParser.OVERLAPS = 125; +PostgreSQLParser.RIGHT = 126; +PostgreSQLParser.SIMILAR = 127; +PostgreSQLParser.VERBOSE = 128; +PostgreSQLParser.ABORT_P = 129; +PostgreSQLParser.ABSOLUTE_P = 130; +PostgreSQLParser.ACCESS = 131; +PostgreSQLParser.ACTION = 132; +PostgreSQLParser.ADD_P = 133; +PostgreSQLParser.ADMIN = 134; +PostgreSQLParser.AFTER = 135; +PostgreSQLParser.AGGREGATE = 136; +PostgreSQLParser.ALSO = 137; +PostgreSQLParser.ALTER = 138; +PostgreSQLParser.ALWAYS = 139; +PostgreSQLParser.ASSERTION = 140; +PostgreSQLParser.ASSIGNMENT = 141; +PostgreSQLParser.AT = 142; +PostgreSQLParser.ATTRIBUTE = 143; +PostgreSQLParser.BACKWARD = 144; +PostgreSQLParser.BEFORE = 145; +PostgreSQLParser.BEGIN_P = 146; +PostgreSQLParser.BY = 147; +PostgreSQLParser.CACHE = 148; +PostgreSQLParser.CALLED = 149; +PostgreSQLParser.CASCADE = 150; +PostgreSQLParser.CASCADED = 151; +PostgreSQLParser.CATALOG = 152; +PostgreSQLParser.CHAIN = 153; +PostgreSQLParser.CHARACTERISTICS = 154; +PostgreSQLParser.CHECKPOINT = 155; +PostgreSQLParser.CLASS = 156; +PostgreSQLParser.CLOSE = 157; +PostgreSQLParser.CLUSTER = 158; +PostgreSQLParser.COMMENT = 159; +PostgreSQLParser.COMMENTS = 160; +PostgreSQLParser.COMMIT = 161; +PostgreSQLParser.COMMITTED = 162; +PostgreSQLParser.CONFIGURATION = 163; +PostgreSQLParser.CONNECTION = 164; +PostgreSQLParser.CONSTRAINTS = 165; +PostgreSQLParser.CONTENT_P = 166; +PostgreSQLParser.CONTINUE_P = 167; +PostgreSQLParser.CONVERSION_P = 168; +PostgreSQLParser.COPY = 169; +PostgreSQLParser.COST = 170; +PostgreSQLParser.CSV = 171; +PostgreSQLParser.CURSOR = 172; +PostgreSQLParser.CYCLE = 173; +PostgreSQLParser.DATA_P = 174; +PostgreSQLParser.DATABASE = 175; +PostgreSQLParser.DAY_P = 176; +PostgreSQLParser.DEALLOCATE = 177; +PostgreSQLParser.DECLARE = 178; +PostgreSQLParser.DEFAULTS = 179; +PostgreSQLParser.DEFERRED = 180; +PostgreSQLParser.DEFINER = 181; +PostgreSQLParser.DELETE_P = 182; +PostgreSQLParser.DELIMITER = 183; +PostgreSQLParser.DELIMITERS = 184; +PostgreSQLParser.DICTIONARY = 185; +PostgreSQLParser.DISABLE_P = 186; +PostgreSQLParser.DISCARD = 187; +PostgreSQLParser.DOCUMENT_P = 188; +PostgreSQLParser.DOMAIN_P = 189; +PostgreSQLParser.DOUBLE_P = 190; +PostgreSQLParser.DROP = 191; +PostgreSQLParser.EACH = 192; +PostgreSQLParser.ENABLE_P = 193; +PostgreSQLParser.ENCODING = 194; +PostgreSQLParser.ENCRYPTED = 195; +PostgreSQLParser.ENUM_P = 196; +PostgreSQLParser.ESCAPE = 197; +PostgreSQLParser.EVENT = 198; +PostgreSQLParser.EXCLUDE = 199; +PostgreSQLParser.EXCLUDING = 200; +PostgreSQLParser.EXCLUSIVE = 201; +PostgreSQLParser.EXECUTE = 202; +PostgreSQLParser.EXPLAIN = 203; +PostgreSQLParser.EXTENSION = 204; +PostgreSQLParser.EXTERNAL = 205; +PostgreSQLParser.FAMILY = 206; +PostgreSQLParser.FIRST_P = 207; +PostgreSQLParser.FOLLOWING = 208; +PostgreSQLParser.FORCE = 209; +PostgreSQLParser.FORWARD = 210; +PostgreSQLParser.FUNCTION = 211; +PostgreSQLParser.FUNCTIONS = 212; +PostgreSQLParser.GLOBAL = 213; +PostgreSQLParser.GRANTED = 214; +PostgreSQLParser.HANDLER = 215; +PostgreSQLParser.HEADER_P = 216; +PostgreSQLParser.HOLD = 217; +PostgreSQLParser.HOUR_P = 218; +PostgreSQLParser.IDENTITY_P = 219; +PostgreSQLParser.IF_P = 220; +PostgreSQLParser.IMMEDIATE = 221; +PostgreSQLParser.IMMUTABLE = 222; +PostgreSQLParser.IMPLICIT_P = 223; +PostgreSQLParser.INCLUDING = 224; +PostgreSQLParser.INCREMENT = 225; +PostgreSQLParser.INDEX = 226; +PostgreSQLParser.INDEXES = 227; +PostgreSQLParser.INHERIT = 228; +PostgreSQLParser.INHERITS = 229; +PostgreSQLParser.INLINE_P = 230; +PostgreSQLParser.INSENSITIVE = 231; +PostgreSQLParser.INSERT = 232; +PostgreSQLParser.INSTEAD = 233; +PostgreSQLParser.INVOKER = 234; +PostgreSQLParser.ISOLATION = 235; +PostgreSQLParser.KEY = 236; +PostgreSQLParser.LABEL = 237; +PostgreSQLParser.LANGUAGE = 238; +PostgreSQLParser.LARGE_P = 239; +PostgreSQLParser.LAST_P = 240; +PostgreSQLParser.LEAKPROOF = 241; +PostgreSQLParser.LEVEL = 242; +PostgreSQLParser.LISTEN = 243; +PostgreSQLParser.LOAD = 244; +PostgreSQLParser.LOCAL = 245; +PostgreSQLParser.LOCATION = 246; +PostgreSQLParser.LOCK_P = 247; +PostgreSQLParser.MAPPING = 248; +PostgreSQLParser.MATCH = 249; +PostgreSQLParser.MATERIALIZED = 250; +PostgreSQLParser.MAXVALUE = 251; +PostgreSQLParser.MINUTE_P = 252; +PostgreSQLParser.MINVALUE = 253; +PostgreSQLParser.MODE = 254; +PostgreSQLParser.MONTH_P = 255; +PostgreSQLParser.MOVE = 256; +PostgreSQLParser.NAME_P = 257; +PostgreSQLParser.NAMES = 258; +PostgreSQLParser.NEXT = 259; +PostgreSQLParser.NO = 260; +PostgreSQLParser.NOTHING = 261; +PostgreSQLParser.NOTIFY = 262; +PostgreSQLParser.NOWAIT = 263; +PostgreSQLParser.NULLS_P = 264; +PostgreSQLParser.OBJECT_P = 265; +PostgreSQLParser.OF = 266; +PostgreSQLParser.OFF = 267; +PostgreSQLParser.OIDS = 268; +PostgreSQLParser.OPERATOR = 269; +PostgreSQLParser.OPTION = 270; +PostgreSQLParser.OPTIONS = 271; +PostgreSQLParser.OWNED = 272; +PostgreSQLParser.OWNER = 273; +PostgreSQLParser.PARSER = 274; +PostgreSQLParser.PARTIAL = 275; +PostgreSQLParser.PARTITION = 276; +PostgreSQLParser.PASSING = 277; +PostgreSQLParser.PASSWORD = 278; +PostgreSQLParser.PLANS = 279; +PostgreSQLParser.PRECEDING = 280; +PostgreSQLParser.PREPARE = 281; +PostgreSQLParser.PREPARED = 282; +PostgreSQLParser.PRESERVE = 283; +PostgreSQLParser.PRIOR = 284; +PostgreSQLParser.PRIVILEGES = 285; +PostgreSQLParser.PROCEDURAL = 286; +PostgreSQLParser.PROCEDURE = 287; +PostgreSQLParser.PROGRAM = 288; +PostgreSQLParser.QUOTE = 289; +PostgreSQLParser.RANGE = 290; +PostgreSQLParser.READ = 291; +PostgreSQLParser.REASSIGN = 292; +PostgreSQLParser.RECHECK = 293; +PostgreSQLParser.RECURSIVE = 294; +PostgreSQLParser.REF = 295; +PostgreSQLParser.REFRESH = 296; +PostgreSQLParser.REINDEX = 297; +PostgreSQLParser.RELATIVE_P = 298; +PostgreSQLParser.RELEASE = 299; +PostgreSQLParser.RENAME = 300; +PostgreSQLParser.REPEATABLE = 301; +PostgreSQLParser.REPLACE = 302; +PostgreSQLParser.REPLICA = 303; +PostgreSQLParser.RESET = 304; +PostgreSQLParser.RESTART = 305; +PostgreSQLParser.RESTRICT = 306; +PostgreSQLParser.RETURNS = 307; +PostgreSQLParser.REVOKE = 308; +PostgreSQLParser.ROLE = 309; +PostgreSQLParser.ROLLBACK = 310; +PostgreSQLParser.ROWS = 311; +PostgreSQLParser.RULE = 312; +PostgreSQLParser.SAVEPOINT = 313; +PostgreSQLParser.SCHEMA = 314; +PostgreSQLParser.SCROLL = 315; +PostgreSQLParser.SEARCH = 316; +PostgreSQLParser.SECOND_P = 317; +PostgreSQLParser.SECURITY = 318; +PostgreSQLParser.SEQUENCE = 319; +PostgreSQLParser.SEQUENCES = 320; +PostgreSQLParser.SERIALIZABLE = 321; +PostgreSQLParser.SERVER = 322; +PostgreSQLParser.SESSION = 323; +PostgreSQLParser.SET = 324; +PostgreSQLParser.SHARE = 325; +PostgreSQLParser.SHOW = 326; +PostgreSQLParser.SIMPLE = 327; +PostgreSQLParser.SNAPSHOT = 328; +PostgreSQLParser.STABLE = 329; +PostgreSQLParser.STANDALONE_P = 330; +PostgreSQLParser.START = 331; +PostgreSQLParser.STATEMENT = 332; +PostgreSQLParser.STATISTICS = 333; +PostgreSQLParser.STDIN = 334; +PostgreSQLParser.STDOUT = 335; +PostgreSQLParser.STORAGE = 336; +PostgreSQLParser.STRICT_P = 337; +PostgreSQLParser.STRIP_P = 338; +PostgreSQLParser.SYSID = 339; +PostgreSQLParser.SYSTEM_P = 340; +PostgreSQLParser.TABLES = 341; +PostgreSQLParser.TABLESPACE = 342; +PostgreSQLParser.TEMP = 343; +PostgreSQLParser.TEMPLATE = 344; +PostgreSQLParser.TEMPORARY = 345; +PostgreSQLParser.TEXT_P = 346; +PostgreSQLParser.TRANSACTION = 347; +PostgreSQLParser.TRIGGER = 348; +PostgreSQLParser.TRUNCATE = 349; +PostgreSQLParser.TRUSTED = 350; +PostgreSQLParser.TYPE_P = 351; +PostgreSQLParser.TYPES_P = 352; +PostgreSQLParser.UNBOUNDED = 353; +PostgreSQLParser.UNCOMMITTED = 354; +PostgreSQLParser.UNENCRYPTED = 355; +PostgreSQLParser.UNKNOWN = 356; +PostgreSQLParser.UNLISTEN = 357; +PostgreSQLParser.UNLOGGED = 358; +PostgreSQLParser.UNTIL = 359; +PostgreSQLParser.UPDATE = 360; +PostgreSQLParser.VACUUM = 361; +PostgreSQLParser.VALID = 362; +PostgreSQLParser.VALIDATE = 363; +PostgreSQLParser.VALIDATOR = 364; +PostgreSQLParser.VARYING = 365; +PostgreSQLParser.VERSION_P = 366; +PostgreSQLParser.VIEW = 367; +PostgreSQLParser.VOLATILE = 368; +PostgreSQLParser.WHITESPACE_P = 369; +PostgreSQLParser.WITHOUT = 370; +PostgreSQLParser.WORK = 371; +PostgreSQLParser.WRAPPER = 372; +PostgreSQLParser.WRITE = 373; +PostgreSQLParser.XML_P = 374; +PostgreSQLParser.YEAR_P = 375; +PostgreSQLParser.YES_P = 376; +PostgreSQLParser.ZONE = 377; +PostgreSQLParser.BETWEEN = 378; +PostgreSQLParser.BIGINT = 379; +PostgreSQLParser.BIT = 380; +PostgreSQLParser.BOOLEAN_P = 381; +PostgreSQLParser.CHAR_P = 382; +PostgreSQLParser.CHARACTER = 383; +PostgreSQLParser.COALESCE = 384; +PostgreSQLParser.DEC = 385; +PostgreSQLParser.DECIMAL_P = 386; +PostgreSQLParser.EXISTS = 387; +PostgreSQLParser.EXTRACT = 388; +PostgreSQLParser.FLOAT_P = 389; +PostgreSQLParser.GREATEST = 390; +PostgreSQLParser.INOUT = 391; +PostgreSQLParser.INT_P = 392; +PostgreSQLParser.INTEGER = 393; +PostgreSQLParser.INTERVAL = 394; +PostgreSQLParser.LEAST = 395; +PostgreSQLParser.NATIONAL = 396; +PostgreSQLParser.NCHAR = 397; +PostgreSQLParser.NONE = 398; +PostgreSQLParser.NULLIF = 399; +PostgreSQLParser.NUMERIC = 400; +PostgreSQLParser.OVERLAY = 401; +PostgreSQLParser.POSITION = 402; +PostgreSQLParser.PRECISION = 403; +PostgreSQLParser.REAL = 404; +PostgreSQLParser.ROW = 405; +PostgreSQLParser.SETOF = 406; +PostgreSQLParser.SMALLINT = 407; +PostgreSQLParser.SUBSTRING = 408; +PostgreSQLParser.TIME = 409; +PostgreSQLParser.TIMESTAMP = 410; +PostgreSQLParser.TREAT = 411; +PostgreSQLParser.TRIM = 412; +PostgreSQLParser.VALUES = 413; +PostgreSQLParser.VARCHAR = 414; +PostgreSQLParser.XMLATTRIBUTES = 415; +PostgreSQLParser.XMLCONCAT = 416; +PostgreSQLParser.XMLELEMENT = 417; +PostgreSQLParser.XMLEXISTS = 418; +PostgreSQLParser.XMLFOREST = 419; +PostgreSQLParser.XMLPARSE = 420; +PostgreSQLParser.XMLPI = 421; +PostgreSQLParser.XMLROOT = 422; +PostgreSQLParser.XMLSERIALIZE = 423; +PostgreSQLParser.CALL = 424; +PostgreSQLParser.CURRENT_P = 425; +PostgreSQLParser.ATTACH = 426; +PostgreSQLParser.DETACH = 427; +PostgreSQLParser.EXPRESSION = 428; +PostgreSQLParser.GENERATED = 429; +PostgreSQLParser.LOGGED = 430; +PostgreSQLParser.STORED = 431; +PostgreSQLParser.INCLUDE = 432; +PostgreSQLParser.ROUTINE = 433; +PostgreSQLParser.TRANSFORM = 434; +PostgreSQLParser.IMPORT_P = 435; +PostgreSQLParser.POLICY = 436; +PostgreSQLParser.METHOD = 437; +PostgreSQLParser.REFERENCING = 438; +PostgreSQLParser.NEW = 439; +PostgreSQLParser.OLD = 440; +PostgreSQLParser.VALUE_P = 441; +PostgreSQLParser.SUBSCRIPTION = 442; +PostgreSQLParser.PUBLICATION = 443; +PostgreSQLParser.OUT_P = 444; +PostgreSQLParser.END_P = 445; +PostgreSQLParser.ROUTINES = 446; +PostgreSQLParser.SCHEMAS = 447; +PostgreSQLParser.PROCEDURES = 448; +PostgreSQLParser.INPUT_P = 449; +PostgreSQLParser.SUPPORT = 450; +PostgreSQLParser.PARALLEL = 451; +PostgreSQLParser.SQL_P = 452; +PostgreSQLParser.DEPENDS = 453; +PostgreSQLParser.OVERRIDING = 454; +PostgreSQLParser.CONFLICT = 455; +PostgreSQLParser.SKIP_P = 456; +PostgreSQLParser.LOCKED = 457; +PostgreSQLParser.TIES = 458; +PostgreSQLParser.ROLLUP = 459; +PostgreSQLParser.CUBE = 460; +PostgreSQLParser.GROUPING = 461; +PostgreSQLParser.SETS = 462; +PostgreSQLParser.TABLESAMPLE = 463; +PostgreSQLParser.ORDINALITY = 464; +PostgreSQLParser.XMLTABLE = 465; +PostgreSQLParser.COLUMNS = 466; +PostgreSQLParser.XMLNAMESPACES = 467; +PostgreSQLParser.ROWTYPE = 468; +PostgreSQLParser.NORMALIZED = 469; +PostgreSQLParser.WITHIN = 470; +PostgreSQLParser.FILTER = 471; +PostgreSQLParser.GROUPS = 472; +PostgreSQLParser.OTHERS = 473; +PostgreSQLParser.NFC = 474; +PostgreSQLParser.NFD = 475; +PostgreSQLParser.NFKC = 476; +PostgreSQLParser.NFKD = 477; +PostgreSQLParser.UESCAPE = 478; +PostgreSQLParser.VIEWS = 479; +PostgreSQLParser.NORMALIZE = 480; +PostgreSQLParser.DUMP = 481; +PostgreSQLParser.PRINT_STRICT_PARAMS = 482; +PostgreSQLParser.VARIABLE_CONFLICT = 483; +PostgreSQLParser.ERROR = 484; +PostgreSQLParser.USE_VARIABLE = 485; +PostgreSQLParser.USE_COLUMN = 486; +PostgreSQLParser.ALIAS = 487; +PostgreSQLParser.CONSTANT = 488; +PostgreSQLParser.PERFORM = 489; +PostgreSQLParser.GET = 490; +PostgreSQLParser.DIAGNOSTICS = 491; +PostgreSQLParser.STACKED = 492; +PostgreSQLParser.ELSIF = 493; +PostgreSQLParser.WHILE = 494; +PostgreSQLParser.REVERSE = 495; +PostgreSQLParser.FOREACH = 496; +PostgreSQLParser.SLICE = 497; +PostgreSQLParser.EXIT = 498; +PostgreSQLParser.RETURN = 499; +PostgreSQLParser.QUERY = 500; +PostgreSQLParser.RAISE = 501; +PostgreSQLParser.SQLSTATE = 502; +PostgreSQLParser.DEBUG = 503; +PostgreSQLParser.LOG = 504; +PostgreSQLParser.INFO = 505; +PostgreSQLParser.NOTICE = 506; +PostgreSQLParser.WARNING = 507; +PostgreSQLParser.EXCEPTION = 508; +PostgreSQLParser.ASSERT = 509; +PostgreSQLParser.LOOP = 510; +PostgreSQLParser.OPEN = 511; +PostgreSQLParser.Identifier = 512; +PostgreSQLParser.QuotedIdentifier = 513; +PostgreSQLParser.UnterminatedQuotedIdentifier = 514; +PostgreSQLParser.InvalidQuotedIdentifier = 515; +PostgreSQLParser.InvalidUnterminatedQuotedIdentifier = 516; +PostgreSQLParser.UnicodeQuotedIdentifier = 517; +PostgreSQLParser.UnterminatedUnicodeQuotedIdentifier = 518; +PostgreSQLParser.InvalidUnicodeQuotedIdentifier = 519; +PostgreSQLParser.InvalidUnterminatedUnicodeQuotedIdentifier = 520; +PostgreSQLParser.StringConstant = 521; +PostgreSQLParser.UnterminatedStringConstant = 522; +PostgreSQLParser.UnicodeEscapeStringConstant = 523; +PostgreSQLParser.UnterminatedUnicodeEscapeStringConstant = 524; +PostgreSQLParser.BeginDollarStringConstant = 525; +PostgreSQLParser.BinaryStringConstant = 526; +PostgreSQLParser.UnterminatedBinaryStringConstant = 527; +PostgreSQLParser.InvalidBinaryStringConstant = 528; +PostgreSQLParser.InvalidUnterminatedBinaryStringConstant = 529; +PostgreSQLParser.HexadecimalStringConstant = 530; +PostgreSQLParser.UnterminatedHexadecimalStringConstant = 531; +PostgreSQLParser.InvalidHexadecimalStringConstant = 532; +PostgreSQLParser.InvalidUnterminatedHexadecimalStringConstant = 533; +PostgreSQLParser.Integral = 534; +PostgreSQLParser.NumericFail = 535; +PostgreSQLParser.Numeric = 536; +PostgreSQLParser.PLSQLVARIABLENAME = 537; +PostgreSQLParser.PLSQLIDENTIFIER = 538; +PostgreSQLParser.Whitespace = 539; +PostgreSQLParser.Newline = 540; +PostgreSQLParser.LineComment = 541; +PostgreSQLParser.BlockComment = 542; +PostgreSQLParser.UnterminatedBlockComment = 543; +PostgreSQLParser.MetaCommand = 544; +PostgreSQLParser.EndMetaCommand = 545; +PostgreSQLParser.ErrorCharacter = 546; +PostgreSQLParser.EscapeStringConstant = 547; +PostgreSQLParser.UnterminatedEscapeStringConstant = 548; +PostgreSQLParser.InvalidEscapeStringConstant = 549; +PostgreSQLParser.InvalidUnterminatedEscapeStringConstant = 550; +PostgreSQLParser.AfterEscapeStringConstantMode_NotContinued = 551; +PostgreSQLParser.AfterEscapeStringConstantWithNewlineMode_NotContinued = 552; +PostgreSQLParser.DollarText = 553; +PostgreSQLParser.EndDollarStringConstant = 554; +PostgreSQLParser.AfterEscapeStringConstantWithNewlineMode_Continued = 555; + +PostgreSQLParser.RULE_root = 0; +PostgreSQLParser.RULE_plsqlroot = 1; +PostgreSQLParser.RULE_stmtblock = 2; +PostgreSQLParser.RULE_stmtmulti = 3; +PostgreSQLParser.RULE_stmt = 4; +PostgreSQLParser.RULE_plsqlconsolecommand = 5; +PostgreSQLParser.RULE_callstmt = 6; +PostgreSQLParser.RULE_createrolestmt = 7; +PostgreSQLParser.RULE_opt_with = 8; +PostgreSQLParser.RULE_optrolelist = 9; +PostgreSQLParser.RULE_alteroptrolelist = 10; +PostgreSQLParser.RULE_alteroptroleelem = 11; +PostgreSQLParser.RULE_createoptroleelem = 12; +PostgreSQLParser.RULE_createuserstmt = 13; +PostgreSQLParser.RULE_alterrolestmt = 14; +PostgreSQLParser.RULE_opt_in_database = 15; +PostgreSQLParser.RULE_alterrolesetstmt = 16; +PostgreSQLParser.RULE_droprolestmt = 17; +PostgreSQLParser.RULE_creategroupstmt = 18; +PostgreSQLParser.RULE_altergroupstmt = 19; +PostgreSQLParser.RULE_add_drop = 20; +PostgreSQLParser.RULE_createschemastmt = 21; +PostgreSQLParser.RULE_optschemaname = 22; +PostgreSQLParser.RULE_optschemaeltlist = 23; +PostgreSQLParser.RULE_schema_stmt = 24; +PostgreSQLParser.RULE_variablesetstmt = 25; +PostgreSQLParser.RULE_set_rest = 26; +PostgreSQLParser.RULE_generic_set = 27; +PostgreSQLParser.RULE_set_rest_more = 28; +PostgreSQLParser.RULE_var_name = 29; +PostgreSQLParser.RULE_var_list = 30; +PostgreSQLParser.RULE_var_value = 31; +PostgreSQLParser.RULE_iso_level = 32; +PostgreSQLParser.RULE_opt_boolean_or_string = 33; +PostgreSQLParser.RULE_zone_value = 34; +PostgreSQLParser.RULE_opt_encoding = 35; +PostgreSQLParser.RULE_nonreservedword_or_sconst = 36; +PostgreSQLParser.RULE_variableresetstmt = 37; +PostgreSQLParser.RULE_reset_rest = 38; +PostgreSQLParser.RULE_generic_reset = 39; +PostgreSQLParser.RULE_setresetclause = 40; +PostgreSQLParser.RULE_functionsetresetclause = 41; +PostgreSQLParser.RULE_variableshowstmt = 42; +PostgreSQLParser.RULE_constraintssetstmt = 43; +PostgreSQLParser.RULE_constraints_set_list = 44; +PostgreSQLParser.RULE_constraints_set_mode = 45; +PostgreSQLParser.RULE_checkpointstmt = 46; +PostgreSQLParser.RULE_discardstmt = 47; +PostgreSQLParser.RULE_altertablestmt = 48; +PostgreSQLParser.RULE_alter_table_cmds = 49; +PostgreSQLParser.RULE_partition_cmd = 50; +PostgreSQLParser.RULE_index_partition_cmd = 51; +PostgreSQLParser.RULE_alter_table_cmd = 52; +PostgreSQLParser.RULE_alter_column_default = 53; +PostgreSQLParser.RULE_opt_drop_behavior = 54; +PostgreSQLParser.RULE_opt_collate_clause = 55; +PostgreSQLParser.RULE_alter_using = 56; +PostgreSQLParser.RULE_replica_identity = 57; +PostgreSQLParser.RULE_reloptions = 58; +PostgreSQLParser.RULE_opt_reloptions = 59; +PostgreSQLParser.RULE_reloption_list = 60; +PostgreSQLParser.RULE_reloption_elem = 61; +PostgreSQLParser.RULE_alter_identity_column_option_list = 62; +PostgreSQLParser.RULE_alter_identity_column_option = 63; +PostgreSQLParser.RULE_partitionboundspec = 64; +PostgreSQLParser.RULE_hash_partbound_elem = 65; +PostgreSQLParser.RULE_hash_partbound = 66; +PostgreSQLParser.RULE_altercompositetypestmt = 67; +PostgreSQLParser.RULE_alter_type_cmds = 68; +PostgreSQLParser.RULE_alter_type_cmd = 69; +PostgreSQLParser.RULE_closeportalstmt = 70; +PostgreSQLParser.RULE_copystmt = 71; +PostgreSQLParser.RULE_copy_from = 72; +PostgreSQLParser.RULE_opt_program = 73; +PostgreSQLParser.RULE_copy_file_name = 74; +PostgreSQLParser.RULE_copy_options = 75; +PostgreSQLParser.RULE_copy_opt_list = 76; +PostgreSQLParser.RULE_copy_opt_item = 77; +PostgreSQLParser.RULE_opt_binary = 78; +PostgreSQLParser.RULE_copy_delimiter = 79; +PostgreSQLParser.RULE_opt_using = 80; +PostgreSQLParser.RULE_copy_generic_opt_list = 81; +PostgreSQLParser.RULE_copy_generic_opt_elem = 82; +PostgreSQLParser.RULE_copy_generic_opt_arg = 83; +PostgreSQLParser.RULE_copy_generic_opt_arg_list = 84; +PostgreSQLParser.RULE_copy_generic_opt_arg_list_item = 85; +PostgreSQLParser.RULE_createstmt = 86; +PostgreSQLParser.RULE_opttemp = 87; +PostgreSQLParser.RULE_opttableelementlist = 88; +PostgreSQLParser.RULE_opttypedtableelementlist = 89; +PostgreSQLParser.RULE_tableelementlist = 90; +PostgreSQLParser.RULE_typedtableelementlist = 91; +PostgreSQLParser.RULE_tableelement = 92; +PostgreSQLParser.RULE_typedtableelement = 93; +PostgreSQLParser.RULE_columnDef = 94; +PostgreSQLParser.RULE_columnOptions = 95; +PostgreSQLParser.RULE_colquallist = 96; +PostgreSQLParser.RULE_colconstraint = 97; +PostgreSQLParser.RULE_colconstraintelem = 98; +PostgreSQLParser.RULE_generated_when = 99; +PostgreSQLParser.RULE_constraintattr = 100; +PostgreSQLParser.RULE_tablelikeclause = 101; +PostgreSQLParser.RULE_tablelikeoptionlist = 102; +PostgreSQLParser.RULE_tablelikeoption = 103; +PostgreSQLParser.RULE_tableconstraint = 104; +PostgreSQLParser.RULE_constraintelem = 105; +PostgreSQLParser.RULE_opt_no_inherit = 106; +PostgreSQLParser.RULE_opt_column_list = 107; +PostgreSQLParser.RULE_columnlist = 108; +PostgreSQLParser.RULE_columnElem = 109; +PostgreSQLParser.RULE_opt_c_include = 110; +PostgreSQLParser.RULE_key_match = 111; +PostgreSQLParser.RULE_exclusionconstraintlist = 112; +PostgreSQLParser.RULE_exclusionconstraintelem = 113; +PostgreSQLParser.RULE_exclusionwhereclause = 114; +PostgreSQLParser.RULE_key_actions = 115; +PostgreSQLParser.RULE_key_update = 116; +PostgreSQLParser.RULE_key_delete = 117; +PostgreSQLParser.RULE_key_action = 118; +PostgreSQLParser.RULE_optinherit = 119; +PostgreSQLParser.RULE_optpartitionspec = 120; +PostgreSQLParser.RULE_partitionspec = 121; +PostgreSQLParser.RULE_part_params = 122; +PostgreSQLParser.RULE_part_elem = 123; +PostgreSQLParser.RULE_table_access_method_clause = 124; +PostgreSQLParser.RULE_optwith = 125; +PostgreSQLParser.RULE_oncommitoption = 126; +PostgreSQLParser.RULE_opttablespace = 127; +PostgreSQLParser.RULE_optconstablespace = 128; +PostgreSQLParser.RULE_existingindex = 129; +PostgreSQLParser.RULE_createstatsstmt = 130; +PostgreSQLParser.RULE_alterstatsstmt = 131; +PostgreSQLParser.RULE_createasstmt = 132; +PostgreSQLParser.RULE_create_as_target = 133; +PostgreSQLParser.RULE_opt_with_data = 134; +PostgreSQLParser.RULE_creatematviewstmt = 135; +PostgreSQLParser.RULE_create_mv_target = 136; +PostgreSQLParser.RULE_optnolog = 137; +PostgreSQLParser.RULE_refreshmatviewstmt = 138; +PostgreSQLParser.RULE_createseqstmt = 139; +PostgreSQLParser.RULE_alterseqstmt = 140; +PostgreSQLParser.RULE_optseqoptlist = 141; +PostgreSQLParser.RULE_optparenthesizedseqoptlist = 142; +PostgreSQLParser.RULE_seqoptlist = 143; +PostgreSQLParser.RULE_seqoptelem = 144; +PostgreSQLParser.RULE_opt_by = 145; +PostgreSQLParser.RULE_numericonly = 146; +PostgreSQLParser.RULE_numericonly_list = 147; +PostgreSQLParser.RULE_createplangstmt = 148; +PostgreSQLParser.RULE_opt_trusted = 149; +PostgreSQLParser.RULE_handler_name = 150; +PostgreSQLParser.RULE_opt_inline_handler = 151; +PostgreSQLParser.RULE_validator_clause = 152; +PostgreSQLParser.RULE_opt_validator = 153; +PostgreSQLParser.RULE_opt_procedural = 154; +PostgreSQLParser.RULE_createtablespacestmt = 155; +PostgreSQLParser.RULE_opttablespaceowner = 156; +PostgreSQLParser.RULE_droptablespacestmt = 157; +PostgreSQLParser.RULE_createextensionstmt = 158; +PostgreSQLParser.RULE_create_extension_opt_list = 159; +PostgreSQLParser.RULE_create_extension_opt_item = 160; +PostgreSQLParser.RULE_alterextensionstmt = 161; +PostgreSQLParser.RULE_alter_extension_opt_list = 162; +PostgreSQLParser.RULE_alter_extension_opt_item = 163; +PostgreSQLParser.RULE_alterextensioncontentsstmt = 164; +PostgreSQLParser.RULE_createfdwstmt = 165; +PostgreSQLParser.RULE_fdw_option = 166; +PostgreSQLParser.RULE_fdw_options = 167; +PostgreSQLParser.RULE_opt_fdw_options = 168; +PostgreSQLParser.RULE_alterfdwstmt = 169; +PostgreSQLParser.RULE_create_generic_options = 170; +PostgreSQLParser.RULE_generic_option_list = 171; +PostgreSQLParser.RULE_alter_generic_options = 172; +PostgreSQLParser.RULE_alter_generic_option_list = 173; +PostgreSQLParser.RULE_alter_generic_option_elem = 174; +PostgreSQLParser.RULE_generic_option_elem = 175; +PostgreSQLParser.RULE_generic_option_name = 176; +PostgreSQLParser.RULE_generic_option_arg = 177; +PostgreSQLParser.RULE_createforeignserverstmt = 178; +PostgreSQLParser.RULE_opt_type = 179; +PostgreSQLParser.RULE_foreign_server_version = 180; +PostgreSQLParser.RULE_opt_foreign_server_version = 181; +PostgreSQLParser.RULE_alterforeignserverstmt = 182; +PostgreSQLParser.RULE_createforeigntablestmt = 183; +PostgreSQLParser.RULE_importforeignschemastmt = 184; +PostgreSQLParser.RULE_import_qualification_type = 185; +PostgreSQLParser.RULE_import_qualification = 186; +PostgreSQLParser.RULE_createusermappingstmt = 187; +PostgreSQLParser.RULE_auth_ident = 188; +PostgreSQLParser.RULE_dropusermappingstmt = 189; +PostgreSQLParser.RULE_alterusermappingstmt = 190; +PostgreSQLParser.RULE_createpolicystmt = 191; +PostgreSQLParser.RULE_alterpolicystmt = 192; +PostgreSQLParser.RULE_rowsecurityoptionalexpr = 193; +PostgreSQLParser.RULE_rowsecurityoptionalwithcheck = 194; +PostgreSQLParser.RULE_rowsecuritydefaulttorole = 195; +PostgreSQLParser.RULE_rowsecurityoptionaltorole = 196; +PostgreSQLParser.RULE_rowsecuritydefaultpermissive = 197; +PostgreSQLParser.RULE_rowsecuritydefaultforcmd = 198; +PostgreSQLParser.RULE_row_security_cmd = 199; +PostgreSQLParser.RULE_createamstmt = 200; +PostgreSQLParser.RULE_am_type = 201; +PostgreSQLParser.RULE_createtrigstmt = 202; +PostgreSQLParser.RULE_triggeractiontime = 203; +PostgreSQLParser.RULE_triggerevents = 204; +PostgreSQLParser.RULE_triggeroneevent = 205; +PostgreSQLParser.RULE_triggerreferencing = 206; +PostgreSQLParser.RULE_triggertransitions = 207; +PostgreSQLParser.RULE_triggertransition = 208; +PostgreSQLParser.RULE_transitionoldornew = 209; +PostgreSQLParser.RULE_transitionrowortable = 210; +PostgreSQLParser.RULE_transitionrelname = 211; +PostgreSQLParser.RULE_triggerforspec = 212; +PostgreSQLParser.RULE_triggerforopteach = 213; +PostgreSQLParser.RULE_triggerfortype = 214; +PostgreSQLParser.RULE_triggerwhen = 215; +PostgreSQLParser.RULE_function_or_procedure = 216; +PostgreSQLParser.RULE_triggerfuncargs = 217; +PostgreSQLParser.RULE_triggerfuncarg = 218; +PostgreSQLParser.RULE_optconstrfromtable = 219; +PostgreSQLParser.RULE_constraintattributespec = 220; +PostgreSQLParser.RULE_constraintattributeElem = 221; +PostgreSQLParser.RULE_createeventtrigstmt = 222; +PostgreSQLParser.RULE_event_trigger_when_list = 223; +PostgreSQLParser.RULE_event_trigger_when_item = 224; +PostgreSQLParser.RULE_event_trigger_value_list = 225; +PostgreSQLParser.RULE_altereventtrigstmt = 226; +PostgreSQLParser.RULE_enable_trigger = 227; +PostgreSQLParser.RULE_createassertionstmt = 228; +PostgreSQLParser.RULE_definestmt = 229; +PostgreSQLParser.RULE_definition = 230; +PostgreSQLParser.RULE_def_list = 231; +PostgreSQLParser.RULE_def_elem = 232; +PostgreSQLParser.RULE_def_arg = 233; +PostgreSQLParser.RULE_old_aggr_definition = 234; +PostgreSQLParser.RULE_old_aggr_list = 235; +PostgreSQLParser.RULE_old_aggr_elem = 236; +PostgreSQLParser.RULE_opt_enum_val_list = 237; +PostgreSQLParser.RULE_enum_val_list = 238; +PostgreSQLParser.RULE_alterenumstmt = 239; +PostgreSQLParser.RULE_opt_if_not_exists = 240; +PostgreSQLParser.RULE_createopclassstmt = 241; +PostgreSQLParser.RULE_opclass_item_list = 242; +PostgreSQLParser.RULE_opclass_item = 243; +PostgreSQLParser.RULE_opt_default = 244; +PostgreSQLParser.RULE_opt_opfamily = 245; +PostgreSQLParser.RULE_opclass_purpose = 246; +PostgreSQLParser.RULE_opt_recheck = 247; +PostgreSQLParser.RULE_createopfamilystmt = 248; +PostgreSQLParser.RULE_alteropfamilystmt = 249; +PostgreSQLParser.RULE_opclass_drop_list = 250; +PostgreSQLParser.RULE_opclass_drop = 251; +PostgreSQLParser.RULE_dropopclassstmt = 252; +PostgreSQLParser.RULE_dropopfamilystmt = 253; +PostgreSQLParser.RULE_dropownedstmt = 254; +PostgreSQLParser.RULE_reassignownedstmt = 255; +PostgreSQLParser.RULE_dropstmt = 256; +PostgreSQLParser.RULE_object_type_any_name = 257; +PostgreSQLParser.RULE_object_type_name = 258; +PostgreSQLParser.RULE_drop_type_name = 259; +PostgreSQLParser.RULE_object_type_name_on_any_name = 260; +PostgreSQLParser.RULE_any_name_list = 261; +PostgreSQLParser.RULE_any_name = 262; +PostgreSQLParser.RULE_attrs = 263; +PostgreSQLParser.RULE_type_name_list = 264; +PostgreSQLParser.RULE_truncatestmt = 265; +PostgreSQLParser.RULE_opt_restart_seqs = 266; +PostgreSQLParser.RULE_commentstmt = 267; +PostgreSQLParser.RULE_comment_text = 268; +PostgreSQLParser.RULE_seclabelstmt = 269; +PostgreSQLParser.RULE_opt_provider = 270; +PostgreSQLParser.RULE_security_label = 271; +PostgreSQLParser.RULE_fetchstmt = 272; +PostgreSQLParser.RULE_fetch_args = 273; +PostgreSQLParser.RULE_from_in = 274; +PostgreSQLParser.RULE_opt_from_in = 275; +PostgreSQLParser.RULE_grantstmt = 276; +PostgreSQLParser.RULE_revokestmt = 277; +PostgreSQLParser.RULE_privileges = 278; +PostgreSQLParser.RULE_privilege_list = 279; +PostgreSQLParser.RULE_privilege = 280; +PostgreSQLParser.RULE_privilege_target = 281; +PostgreSQLParser.RULE_grantee_list = 282; +PostgreSQLParser.RULE_grantee = 283; +PostgreSQLParser.RULE_opt_grant_grant_option = 284; +PostgreSQLParser.RULE_grantrolestmt = 285; +PostgreSQLParser.RULE_revokerolestmt = 286; +PostgreSQLParser.RULE_opt_grant_admin_option = 287; +PostgreSQLParser.RULE_opt_granted_by = 288; +PostgreSQLParser.RULE_alterdefaultprivilegesstmt = 289; +PostgreSQLParser.RULE_defacloptionlist = 290; +PostgreSQLParser.RULE_defacloption = 291; +PostgreSQLParser.RULE_defaclaction = 292; +PostgreSQLParser.RULE_defacl_privilege_target = 293; +PostgreSQLParser.RULE_indexstmt = 294; +PostgreSQLParser.RULE_opt_unique = 295; +PostgreSQLParser.RULE_opt_concurrently = 296; +PostgreSQLParser.RULE_opt_index_name = 297; +PostgreSQLParser.RULE_access_method_clause = 298; +PostgreSQLParser.RULE_index_params = 299; +PostgreSQLParser.RULE_index_elem_options = 300; +PostgreSQLParser.RULE_index_elem = 301; +PostgreSQLParser.RULE_opt_include = 302; +PostgreSQLParser.RULE_index_including_params = 303; +PostgreSQLParser.RULE_opt_collate = 304; +PostgreSQLParser.RULE_opt_class = 305; +PostgreSQLParser.RULE_opt_asc_desc = 306; +PostgreSQLParser.RULE_opt_nulls_order = 307; +PostgreSQLParser.RULE_createfunctionstmt = 308; +PostgreSQLParser.RULE_opt_or_replace = 309; +PostgreSQLParser.RULE_func_args = 310; +PostgreSQLParser.RULE_func_args_list = 311; +PostgreSQLParser.RULE_function_with_argtypes_list = 312; +PostgreSQLParser.RULE_function_with_argtypes = 313; +PostgreSQLParser.RULE_func_args_with_defaults = 314; +PostgreSQLParser.RULE_func_args_with_defaults_list = 315; +PostgreSQLParser.RULE_func_arg = 316; +PostgreSQLParser.RULE_arg_class = 317; +PostgreSQLParser.RULE_param_name = 318; +PostgreSQLParser.RULE_func_return = 319; +PostgreSQLParser.RULE_func_type = 320; +PostgreSQLParser.RULE_func_arg_with_default = 321; +PostgreSQLParser.RULE_aggr_arg = 322; +PostgreSQLParser.RULE_aggr_args = 323; +PostgreSQLParser.RULE_aggr_args_list = 324; +PostgreSQLParser.RULE_aggregate_with_argtypes = 325; +PostgreSQLParser.RULE_aggregate_with_argtypes_list = 326; +PostgreSQLParser.RULE_createfunc_opt_list = 327; +PostgreSQLParser.RULE_common_func_opt_item = 328; +PostgreSQLParser.RULE_createfunc_opt_item = 329; +PostgreSQLParser.RULE_func_as = 330; +PostgreSQLParser.RULE_transform_type_list = 331; +PostgreSQLParser.RULE_opt_definition = 332; +PostgreSQLParser.RULE_table_func_column = 333; +PostgreSQLParser.RULE_table_func_column_list = 334; +PostgreSQLParser.RULE_alterfunctionstmt = 335; +PostgreSQLParser.RULE_alterfunc_opt_list = 336; +PostgreSQLParser.RULE_opt_restrict = 337; +PostgreSQLParser.RULE_removefuncstmt = 338; +PostgreSQLParser.RULE_removeaggrstmt = 339; +PostgreSQLParser.RULE_removeoperstmt = 340; +PostgreSQLParser.RULE_oper_argtypes = 341; +PostgreSQLParser.RULE_any_operator = 342; +PostgreSQLParser.RULE_operator_with_argtypes_list = 343; +PostgreSQLParser.RULE_operator_with_argtypes = 344; +PostgreSQLParser.RULE_dostmt = 345; +PostgreSQLParser.RULE_dostmt_opt_list = 346; +PostgreSQLParser.RULE_dostmt_opt_item = 347; +PostgreSQLParser.RULE_createcaststmt = 348; +PostgreSQLParser.RULE_cast_context = 349; +PostgreSQLParser.RULE_dropcaststmt = 350; +PostgreSQLParser.RULE_opt_if_exists = 351; +PostgreSQLParser.RULE_createtransformstmt = 352; +PostgreSQLParser.RULE_transform_element_list = 353; +PostgreSQLParser.RULE_droptransformstmt = 354; +PostgreSQLParser.RULE_reindexstmt = 355; +PostgreSQLParser.RULE_reindex_target_type = 356; +PostgreSQLParser.RULE_reindex_target_multitable = 357; +PostgreSQLParser.RULE_reindex_option_list = 358; +PostgreSQLParser.RULE_reindex_option_elem = 359; +PostgreSQLParser.RULE_altertblspcstmt = 360; +PostgreSQLParser.RULE_renamestmt = 361; +PostgreSQLParser.RULE_opt_column = 362; +PostgreSQLParser.RULE_opt_set_data = 363; +PostgreSQLParser.RULE_alterobjectdependsstmt = 364; +PostgreSQLParser.RULE_opt_no = 365; +PostgreSQLParser.RULE_alterobjectschemastmt = 366; +PostgreSQLParser.RULE_alteroperatorstmt = 367; +PostgreSQLParser.RULE_operator_def_list = 368; +PostgreSQLParser.RULE_operator_def_elem = 369; +PostgreSQLParser.RULE_operator_def_arg = 370; +PostgreSQLParser.RULE_altertypestmt = 371; +PostgreSQLParser.RULE_alterownerstmt = 372; +PostgreSQLParser.RULE_createpublicationstmt = 373; +PostgreSQLParser.RULE_opt_publication_for_tables = 374; +PostgreSQLParser.RULE_publication_for_tables = 375; +PostgreSQLParser.RULE_alterpublicationstmt = 376; +PostgreSQLParser.RULE_createsubscriptionstmt = 377; +PostgreSQLParser.RULE_publication_name_list = 378; +PostgreSQLParser.RULE_publication_name_item = 379; +PostgreSQLParser.RULE_altersubscriptionstmt = 380; +PostgreSQLParser.RULE_dropsubscriptionstmt = 381; +PostgreSQLParser.RULE_rulestmt = 382; +PostgreSQLParser.RULE_ruleactionlist = 383; +PostgreSQLParser.RULE_ruleactionmulti = 384; +PostgreSQLParser.RULE_ruleactionstmt = 385; +PostgreSQLParser.RULE_ruleactionstmtOrEmpty = 386; +PostgreSQLParser.RULE_event = 387; +PostgreSQLParser.RULE_opt_instead = 388; +PostgreSQLParser.RULE_notifystmt = 389; +PostgreSQLParser.RULE_notify_payload = 390; +PostgreSQLParser.RULE_listenstmt = 391; +PostgreSQLParser.RULE_unlistenstmt = 392; +PostgreSQLParser.RULE_transactionstmt = 393; +PostgreSQLParser.RULE_opt_transaction = 394; +PostgreSQLParser.RULE_transaction_mode_item = 395; +PostgreSQLParser.RULE_transaction_mode_list = 396; +PostgreSQLParser.RULE_transaction_mode_list_or_empty = 397; +PostgreSQLParser.RULE_opt_transaction_chain = 398; +PostgreSQLParser.RULE_viewstmt = 399; +PostgreSQLParser.RULE_opt_check_option = 400; +PostgreSQLParser.RULE_loadstmt = 401; +PostgreSQLParser.RULE_createdbstmt = 402; +PostgreSQLParser.RULE_createdb_opt_list = 403; +PostgreSQLParser.RULE_createdb_opt_items = 404; +PostgreSQLParser.RULE_createdb_opt_item = 405; +PostgreSQLParser.RULE_createdb_opt_name = 406; +PostgreSQLParser.RULE_opt_equal = 407; +PostgreSQLParser.RULE_alterdatabasestmt = 408; +PostgreSQLParser.RULE_alterdatabasesetstmt = 409; +PostgreSQLParser.RULE_dropdbstmt = 410; +PostgreSQLParser.RULE_drop_option_list = 411; +PostgreSQLParser.RULE_drop_option = 412; +PostgreSQLParser.RULE_altercollationstmt = 413; +PostgreSQLParser.RULE_altersystemstmt = 414; +PostgreSQLParser.RULE_createdomainstmt = 415; +PostgreSQLParser.RULE_alterdomainstmt = 416; +PostgreSQLParser.RULE_opt_as = 417; +PostgreSQLParser.RULE_altertsdictionarystmt = 418; +PostgreSQLParser.RULE_altertsconfigurationstmt = 419; +PostgreSQLParser.RULE_any_with = 420; +PostgreSQLParser.RULE_createconversionstmt = 421; +PostgreSQLParser.RULE_clusterstmt = 422; +PostgreSQLParser.RULE_cluster_index_specification = 423; +PostgreSQLParser.RULE_vacuumstmt = 424; +PostgreSQLParser.RULE_analyzestmt = 425; +PostgreSQLParser.RULE_vac_analyze_option_list = 426; +PostgreSQLParser.RULE_analyze_keyword = 427; +PostgreSQLParser.RULE_vac_analyze_option_elem = 428; +PostgreSQLParser.RULE_vac_analyze_option_name = 429; +PostgreSQLParser.RULE_vac_analyze_option_arg = 430; +PostgreSQLParser.RULE_opt_analyze = 431; +PostgreSQLParser.RULE_opt_verbose = 432; +PostgreSQLParser.RULE_opt_full = 433; +PostgreSQLParser.RULE_opt_freeze = 434; +PostgreSQLParser.RULE_opt_name_list = 435; +PostgreSQLParser.RULE_vacuum_relation = 436; +PostgreSQLParser.RULE_vacuum_relation_list = 437; +PostgreSQLParser.RULE_opt_vacuum_relation_list = 438; +PostgreSQLParser.RULE_explainstmt = 439; +PostgreSQLParser.RULE_explainablestmt = 440; +PostgreSQLParser.RULE_explain_option_list = 441; +PostgreSQLParser.RULE_explain_option_elem = 442; +PostgreSQLParser.RULE_explain_option_name = 443; +PostgreSQLParser.RULE_explain_option_arg = 444; +PostgreSQLParser.RULE_preparestmt = 445; +PostgreSQLParser.RULE_prep_type_clause = 446; +PostgreSQLParser.RULE_preparablestmt = 447; +PostgreSQLParser.RULE_executestmt = 448; +PostgreSQLParser.RULE_execute_param_clause = 449; +PostgreSQLParser.RULE_deallocatestmt = 450; +PostgreSQLParser.RULE_insertstmt = 451; +PostgreSQLParser.RULE_insert_target = 452; +PostgreSQLParser.RULE_insert_rest = 453; +PostgreSQLParser.RULE_override_kind = 454; +PostgreSQLParser.RULE_insert_column_list = 455; +PostgreSQLParser.RULE_insert_column_item = 456; +PostgreSQLParser.RULE_opt_on_conflict = 457; +PostgreSQLParser.RULE_opt_conf_expr = 458; +PostgreSQLParser.RULE_returning_clause = 459; +PostgreSQLParser.RULE_deletestmt = 460; +PostgreSQLParser.RULE_using_clause = 461; +PostgreSQLParser.RULE_lockstmt = 462; +PostgreSQLParser.RULE_opt_lock = 463; +PostgreSQLParser.RULE_lock_type = 464; +PostgreSQLParser.RULE_opt_nowait = 465; +PostgreSQLParser.RULE_opt_nowait_or_skip = 466; +PostgreSQLParser.RULE_updatestmt = 467; +PostgreSQLParser.RULE_set_clause_list = 468; +PostgreSQLParser.RULE_set_clause = 469; +PostgreSQLParser.RULE_set_target = 470; +PostgreSQLParser.RULE_set_target_list = 471; +PostgreSQLParser.RULE_declarecursorstmt = 472; +PostgreSQLParser.RULE_cursor_name = 473; +PostgreSQLParser.RULE_cursor_options = 474; +PostgreSQLParser.RULE_opt_hold = 475; +PostgreSQLParser.RULE_selectstmt = 476; +PostgreSQLParser.RULE_select_with_parens = 477; +PostgreSQLParser.RULE_select_no_parens = 478; +PostgreSQLParser.RULE_select_clause = 479; +PostgreSQLParser.RULE_simple_select = 480; +PostgreSQLParser.RULE_set_operator = 481; +PostgreSQLParser.RULE_set_operator_with_all_or_distinct = 482; +PostgreSQLParser.RULE_with_clause = 483; +PostgreSQLParser.RULE_cte_list = 484; +PostgreSQLParser.RULE_common_table_expr = 485; +PostgreSQLParser.RULE_opt_materialized = 486; +PostgreSQLParser.RULE_opt_with_clause = 487; +PostgreSQLParser.RULE_into_clause = 488; +PostgreSQLParser.RULE_opt_strict = 489; +PostgreSQLParser.RULE_opttempTableName = 490; +PostgreSQLParser.RULE_opt_table = 491; +PostgreSQLParser.RULE_all_or_distinct = 492; +PostgreSQLParser.RULE_distinct_clause = 493; +PostgreSQLParser.RULE_opt_all_clause = 494; +PostgreSQLParser.RULE_opt_sort_clause = 495; +PostgreSQLParser.RULE_sort_clause = 496; +PostgreSQLParser.RULE_sortby_list = 497; +PostgreSQLParser.RULE_sortby = 498; +PostgreSQLParser.RULE_select_limit = 499; +PostgreSQLParser.RULE_opt_select_limit = 500; +PostgreSQLParser.RULE_limit_clause = 501; +PostgreSQLParser.RULE_offset_clause = 502; +PostgreSQLParser.RULE_select_limit_value = 503; +PostgreSQLParser.RULE_select_offset_value = 504; +PostgreSQLParser.RULE_select_fetch_first_value = 505; +PostgreSQLParser.RULE_i_or_f_const = 506; +PostgreSQLParser.RULE_row_or_rows = 507; +PostgreSQLParser.RULE_first_or_next = 508; +PostgreSQLParser.RULE_group_clause = 509; +PostgreSQLParser.RULE_group_by_list = 510; +PostgreSQLParser.RULE_group_by_item = 511; +PostgreSQLParser.RULE_empty_grouping_set = 512; +PostgreSQLParser.RULE_rollup_clause = 513; +PostgreSQLParser.RULE_cube_clause = 514; +PostgreSQLParser.RULE_grouping_sets_clause = 515; +PostgreSQLParser.RULE_having_clause = 516; +PostgreSQLParser.RULE_for_locking_clause = 517; +PostgreSQLParser.RULE_opt_for_locking_clause = 518; +PostgreSQLParser.RULE_for_locking_items = 519; +PostgreSQLParser.RULE_for_locking_item = 520; +PostgreSQLParser.RULE_for_locking_strength = 521; +PostgreSQLParser.RULE_locked_rels_list = 522; +PostgreSQLParser.RULE_values_clause = 523; +PostgreSQLParser.RULE_from_clause = 524; +PostgreSQLParser.RULE_from_list = 525; +PostgreSQLParser.RULE_table_ref = 526; +PostgreSQLParser.RULE_alias_clause = 527; +PostgreSQLParser.RULE_opt_alias_clause = 528; +PostgreSQLParser.RULE_func_alias_clause = 529; +PostgreSQLParser.RULE_join_type = 530; +PostgreSQLParser.RULE_join_qual = 531; +PostgreSQLParser.RULE_relation_expr = 532; +PostgreSQLParser.RULE_relation_expr_list = 533; +PostgreSQLParser.RULE_relation_expr_opt_alias = 534; +PostgreSQLParser.RULE_tablesample_clause = 535; +PostgreSQLParser.RULE_opt_repeatable_clause = 536; +PostgreSQLParser.RULE_func_table = 537; +PostgreSQLParser.RULE_rowsfrom_item = 538; +PostgreSQLParser.RULE_rowsfrom_list = 539; +PostgreSQLParser.RULE_opt_col_def_list = 540; +PostgreSQLParser.RULE_opt_ordinality = 541; +PostgreSQLParser.RULE_where_clause = 542; +PostgreSQLParser.RULE_where_or_current_clause = 543; +PostgreSQLParser.RULE_opttablefuncelementlist = 544; +PostgreSQLParser.RULE_tablefuncelementlist = 545; +PostgreSQLParser.RULE_tablefuncelement = 546; +PostgreSQLParser.RULE_xmltable = 547; +PostgreSQLParser.RULE_xmltable_column_list = 548; +PostgreSQLParser.RULE_xmltable_column_el = 549; +PostgreSQLParser.RULE_xmltable_column_option_list = 550; +PostgreSQLParser.RULE_xmltable_column_option_el = 551; +PostgreSQLParser.RULE_xml_namespace_list = 552; +PostgreSQLParser.RULE_xml_namespace_el = 553; +PostgreSQLParser.RULE_typename = 554; +PostgreSQLParser.RULE_opt_array_bounds = 555; +PostgreSQLParser.RULE_simpletypename = 556; +PostgreSQLParser.RULE_consttypename = 557; +PostgreSQLParser.RULE_generictype = 558; +PostgreSQLParser.RULE_opt_type_modifiers = 559; +PostgreSQLParser.RULE_numeric = 560; +PostgreSQLParser.RULE_opt_float = 561; +PostgreSQLParser.RULE_bit = 562; +PostgreSQLParser.RULE_constbit = 563; +PostgreSQLParser.RULE_bitwithlength = 564; +PostgreSQLParser.RULE_bitwithoutlength = 565; +PostgreSQLParser.RULE_character = 566; +PostgreSQLParser.RULE_constcharacter = 567; +PostgreSQLParser.RULE_character_c = 568; +PostgreSQLParser.RULE_opt_varying = 569; +PostgreSQLParser.RULE_constdatetime = 570; +PostgreSQLParser.RULE_constinterval = 571; +PostgreSQLParser.RULE_opt_timezone = 572; +PostgreSQLParser.RULE_opt_interval = 573; +PostgreSQLParser.RULE_interval_second = 574; +PostgreSQLParser.RULE_opt_escape = 575; +PostgreSQLParser.RULE_a_expr = 576; +PostgreSQLParser.RULE_a_expr_qual = 577; +PostgreSQLParser.RULE_a_expr_lessless = 578; +PostgreSQLParser.RULE_a_expr_or = 579; +PostgreSQLParser.RULE_a_expr_and = 580; +PostgreSQLParser.RULE_a_expr_in = 581; +PostgreSQLParser.RULE_a_expr_unary_not = 582; +PostgreSQLParser.RULE_a_expr_isnull = 583; +PostgreSQLParser.RULE_a_expr_is_not = 584; +PostgreSQLParser.RULE_a_expr_compare = 585; +PostgreSQLParser.RULE_a_expr_like = 586; +PostgreSQLParser.RULE_a_expr_qual_op = 587; +PostgreSQLParser.RULE_a_expr_unary_qualop = 588; +PostgreSQLParser.RULE_a_expr_add = 589; +PostgreSQLParser.RULE_a_expr_mul = 590; +PostgreSQLParser.RULE_a_expr_caret = 591; +PostgreSQLParser.RULE_a_expr_unary_sign = 592; +PostgreSQLParser.RULE_a_expr_at_time_zone = 593; +PostgreSQLParser.RULE_a_expr_collate = 594; +PostgreSQLParser.RULE_a_expr_typecast = 595; +PostgreSQLParser.RULE_b_expr = 596; +PostgreSQLParser.RULE_c_expr = 597; +PostgreSQLParser.RULE_plsqlvariablename = 598; +PostgreSQLParser.RULE_func_application = 599; +PostgreSQLParser.RULE_func_expr = 600; +PostgreSQLParser.RULE_func_expr_windowless = 601; +PostgreSQLParser.RULE_func_expr_common_subexpr = 602; +PostgreSQLParser.RULE_xml_root_version = 603; +PostgreSQLParser.RULE_opt_xml_root_standalone = 604; +PostgreSQLParser.RULE_xml_attributes = 605; +PostgreSQLParser.RULE_xml_attribute_list = 606; +PostgreSQLParser.RULE_xml_attribute_el = 607; +PostgreSQLParser.RULE_document_or_content = 608; +PostgreSQLParser.RULE_xml_whitespace_option = 609; +PostgreSQLParser.RULE_xmlexists_argument = 610; +PostgreSQLParser.RULE_xml_passing_mech = 611; +PostgreSQLParser.RULE_within_group_clause = 612; +PostgreSQLParser.RULE_filter_clause = 613; +PostgreSQLParser.RULE_window_clause = 614; +PostgreSQLParser.RULE_window_definition_list = 615; +PostgreSQLParser.RULE_window_definition = 616; +PostgreSQLParser.RULE_over_clause = 617; +PostgreSQLParser.RULE_window_specification = 618; +PostgreSQLParser.RULE_opt_existing_window_name = 619; +PostgreSQLParser.RULE_opt_partition_clause = 620; +PostgreSQLParser.RULE_opt_frame_clause = 621; +PostgreSQLParser.RULE_frame_extent = 622; +PostgreSQLParser.RULE_frame_bound = 623; +PostgreSQLParser.RULE_opt_window_exclusion_clause = 624; +PostgreSQLParser.RULE_row = 625; +PostgreSQLParser.RULE_explicit_row = 626; +PostgreSQLParser.RULE_implicit_row = 627; +PostgreSQLParser.RULE_sub_type = 628; +PostgreSQLParser.RULE_all_op = 629; +PostgreSQLParser.RULE_mathop = 630; +PostgreSQLParser.RULE_qual_op = 631; +PostgreSQLParser.RULE_qual_all_op = 632; +PostgreSQLParser.RULE_subquery_Op = 633; +PostgreSQLParser.RULE_expr_list = 634; +PostgreSQLParser.RULE_func_arg_list = 635; +PostgreSQLParser.RULE_func_arg_expr = 636; +PostgreSQLParser.RULE_type_list = 637; +PostgreSQLParser.RULE_array_expr = 638; +PostgreSQLParser.RULE_array_expr_list = 639; +PostgreSQLParser.RULE_extract_list = 640; +PostgreSQLParser.RULE_extract_arg = 641; +PostgreSQLParser.RULE_unicode_normal_form = 642; +PostgreSQLParser.RULE_overlay_list = 643; +PostgreSQLParser.RULE_position_list = 644; +PostgreSQLParser.RULE_substr_list = 645; +PostgreSQLParser.RULE_trim_list = 646; +PostgreSQLParser.RULE_in_expr = 647; +PostgreSQLParser.RULE_case_expr = 648; +PostgreSQLParser.RULE_when_clause_list = 649; +PostgreSQLParser.RULE_when_clause = 650; +PostgreSQLParser.RULE_case_default = 651; +PostgreSQLParser.RULE_case_arg = 652; +PostgreSQLParser.RULE_columnref = 653; +PostgreSQLParser.RULE_indirection_el = 654; +PostgreSQLParser.RULE_opt_slice_bound = 655; +PostgreSQLParser.RULE_indirection = 656; +PostgreSQLParser.RULE_opt_indirection = 657; +PostgreSQLParser.RULE_opt_target_list = 658; +PostgreSQLParser.RULE_target_list = 659; +PostgreSQLParser.RULE_target_el = 660; +PostgreSQLParser.RULE_qualified_name_list = 661; +PostgreSQLParser.RULE_qualified_name = 662; +PostgreSQLParser.RULE_name_list = 663; +PostgreSQLParser.RULE_name = 664; +PostgreSQLParser.RULE_attr_name = 665; +PostgreSQLParser.RULE_file_name = 666; +PostgreSQLParser.RULE_func_name = 667; +PostgreSQLParser.RULE_aexprconst = 668; +PostgreSQLParser.RULE_xconst = 669; +PostgreSQLParser.RULE_bconst = 670; +PostgreSQLParser.RULE_fconst = 671; +PostgreSQLParser.RULE_iconst = 672; +PostgreSQLParser.RULE_sconst = 673; +PostgreSQLParser.RULE_anysconst = 674; +PostgreSQLParser.RULE_opt_uescape = 675; +PostgreSQLParser.RULE_signediconst = 676; +PostgreSQLParser.RULE_roleid = 677; +PostgreSQLParser.RULE_rolespec = 678; +PostgreSQLParser.RULE_role_list = 679; +PostgreSQLParser.RULE_colid = 680; +PostgreSQLParser.RULE_type_function_name = 681; +PostgreSQLParser.RULE_nonreservedword = 682; +PostgreSQLParser.RULE_collabel = 683; +PostgreSQLParser.RULE_identifier = 684; +PostgreSQLParser.RULE_plsqlidentifier = 685; +PostgreSQLParser.RULE_unreserved_keyword = 686; +PostgreSQLParser.RULE_col_name_keyword = 687; +PostgreSQLParser.RULE_type_func_name_keyword = 688; +PostgreSQLParser.RULE_reserved_keyword = 689; +PostgreSQLParser.RULE_pl_function = 690; +PostgreSQLParser.RULE_comp_options = 691; +PostgreSQLParser.RULE_comp_option = 692; +PostgreSQLParser.RULE_sharp = 693; +PostgreSQLParser.RULE_option_value = 694; +PostgreSQLParser.RULE_opt_semi = 695; +PostgreSQLParser.RULE_pl_block = 696; +PostgreSQLParser.RULE_decl_sect = 697; +PostgreSQLParser.RULE_decl_start = 698; +PostgreSQLParser.RULE_decl_stmts = 699; +PostgreSQLParser.RULE_label_decl = 700; +PostgreSQLParser.RULE_decl_stmt = 701; +PostgreSQLParser.RULE_decl_statement = 702; +PostgreSQLParser.RULE_opt_scrollable = 703; +PostgreSQLParser.RULE_decl_cursor_query = 704; +PostgreSQLParser.RULE_decl_cursor_args = 705; +PostgreSQLParser.RULE_decl_cursor_arglist = 706; +PostgreSQLParser.RULE_decl_cursor_arg = 707; +PostgreSQLParser.RULE_decl_is_for = 708; +PostgreSQLParser.RULE_decl_aliasitem = 709; +PostgreSQLParser.RULE_decl_varname = 710; +PostgreSQLParser.RULE_decl_const = 711; +PostgreSQLParser.RULE_decl_datatype = 712; +PostgreSQLParser.RULE_decl_collate = 713; +PostgreSQLParser.RULE_decl_notnull = 714; +PostgreSQLParser.RULE_decl_defval = 715; +PostgreSQLParser.RULE_decl_defkey = 716; +PostgreSQLParser.RULE_assign_operator = 717; +PostgreSQLParser.RULE_proc_sect = 718; +PostgreSQLParser.RULE_proc_stmt = 719; +PostgreSQLParser.RULE_stmt_perform = 720; +PostgreSQLParser.RULE_stmt_call = 721; +PostgreSQLParser.RULE_opt_expr_list = 722; +PostgreSQLParser.RULE_stmt_assign = 723; +PostgreSQLParser.RULE_stmt_getdiag = 724; +PostgreSQLParser.RULE_getdiag_area_opt = 725; +PostgreSQLParser.RULE_getdiag_list = 726; +PostgreSQLParser.RULE_getdiag_list_item = 727; +PostgreSQLParser.RULE_getdiag_item = 728; +PostgreSQLParser.RULE_getdiag_target = 729; +PostgreSQLParser.RULE_assign_var = 730; +PostgreSQLParser.RULE_stmt_if = 731; +PostgreSQLParser.RULE_stmt_elsifs = 732; +PostgreSQLParser.RULE_stmt_else = 733; +PostgreSQLParser.RULE_stmt_case = 734; +PostgreSQLParser.RULE_opt_expr_until_when = 735; +PostgreSQLParser.RULE_case_when_list = 736; +PostgreSQLParser.RULE_case_when = 737; +PostgreSQLParser.RULE_opt_case_else = 738; +PostgreSQLParser.RULE_stmt_loop = 739; +PostgreSQLParser.RULE_stmt_while = 740; +PostgreSQLParser.RULE_stmt_for = 741; +PostgreSQLParser.RULE_for_control = 742; +PostgreSQLParser.RULE_opt_for_using_expression = 743; +PostgreSQLParser.RULE_opt_cursor_parameters = 744; +PostgreSQLParser.RULE_opt_reverse = 745; +PostgreSQLParser.RULE_opt_by_expression = 746; +PostgreSQLParser.RULE_for_variable = 747; +PostgreSQLParser.RULE_stmt_foreach_a = 748; +PostgreSQLParser.RULE_foreach_slice = 749; +PostgreSQLParser.RULE_stmt_exit = 750; +PostgreSQLParser.RULE_exit_type = 751; +PostgreSQLParser.RULE_stmt_return = 752; +PostgreSQLParser.RULE_opt_return_result = 753; +PostgreSQLParser.RULE_stmt_raise = 754; +PostgreSQLParser.RULE_opt_stmt_raise_level = 755; +PostgreSQLParser.RULE_opt_raise_list = 756; +PostgreSQLParser.RULE_opt_raise_using = 757; +PostgreSQLParser.RULE_opt_raise_using_elem = 758; +PostgreSQLParser.RULE_opt_raise_using_elem_list = 759; +PostgreSQLParser.RULE_stmt_assert = 760; +PostgreSQLParser.RULE_opt_stmt_assert_message = 761; +PostgreSQLParser.RULE_loop_body = 762; +PostgreSQLParser.RULE_stmt_execsql = 763; +PostgreSQLParser.RULE_stmt_dynexecute = 764; +PostgreSQLParser.RULE_opt_execute_using = 765; +PostgreSQLParser.RULE_opt_execute_using_list = 766; +PostgreSQLParser.RULE_opt_execute_into = 767; +PostgreSQLParser.RULE_stmt_open = 768; +PostgreSQLParser.RULE_opt_open_bound_list_item = 769; +PostgreSQLParser.RULE_opt_open_bound_list = 770; +PostgreSQLParser.RULE_opt_open_using = 771; +PostgreSQLParser.RULE_opt_scroll_option = 772; +PostgreSQLParser.RULE_opt_scroll_option_no = 773; +PostgreSQLParser.RULE_stmt_fetch = 774; +PostgreSQLParser.RULE_into_target = 775; +PostgreSQLParser.RULE_opt_cursor_from = 776; +PostgreSQLParser.RULE_opt_fetch_direction = 777; +PostgreSQLParser.RULE_stmt_move = 778; +PostgreSQLParser.RULE_stmt_close = 779; +PostgreSQLParser.RULE_stmt_null = 780; +PostgreSQLParser.RULE_stmt_commit = 781; +PostgreSQLParser.RULE_stmt_rollback = 782; +PostgreSQLParser.RULE_plsql_opt_transaction_chain = 783; +PostgreSQLParser.RULE_stmt_set = 784; +PostgreSQLParser.RULE_cursor_variable = 785; +PostgreSQLParser.RULE_exception_sect = 786; +PostgreSQLParser.RULE_proc_exceptions = 787; +PostgreSQLParser.RULE_proc_exception = 788; +PostgreSQLParser.RULE_proc_conditions = 789; +PostgreSQLParser.RULE_proc_condition = 790; +PostgreSQLParser.RULE_opt_block_label = 791; +PostgreSQLParser.RULE_opt_loop_label = 792; +PostgreSQLParser.RULE_opt_label = 793; +PostgreSQLParser.RULE_opt_exitcond = 794; +PostgreSQLParser.RULE_any_identifier = 795; +PostgreSQLParser.RULE_plsql_unreserved_keyword = 796; +PostgreSQLParser.RULE_sql_expression = 797; +PostgreSQLParser.RULE_expr_until_then = 798; +PostgreSQLParser.RULE_expr_until_semi = 799; +PostgreSQLParser.RULE_expr_until_rightbracket = 800; +PostgreSQLParser.RULE_expr_until_loop = 801; +PostgreSQLParser.RULE_make_execsql_stmt = 802; +PostgreSQLParser.RULE_opt_returning_clause_into = 803; + + +function RootContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_root; + return this; +} + +RootContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RootContext.prototype.constructor = RootContext; + +RootContext.prototype.stmtblock = function() { + return this.getTypedRuleContext(StmtblockContext,0); +}; + +RootContext.prototype.EOF = function() { + return this.getToken(PostgreSQLParser.EOF, 0); +}; + +RootContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRoot(this); + } +}; + +RootContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRoot(this); + } +}; + +RootContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRoot(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RootContext = RootContext; + +PostgreSQLParser.prototype.root = function() { + + var localctx = new RootContext(this, this._ctx, this.state); + this.enterRule(localctx, 0, PostgreSQLParser.RULE_root); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1608; + this.stmtblock(); + this.state = 1609; + this.match(PostgreSQLParser.EOF); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function PlsqlrootContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_plsqlroot; + return this; +} + +PlsqlrootContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +PlsqlrootContext.prototype.constructor = PlsqlrootContext; + +PlsqlrootContext.prototype.pl_function = function() { + return this.getTypedRuleContext(Pl_functionContext,0); +}; + +PlsqlrootContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPlsqlroot(this); + } +}; + +PlsqlrootContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPlsqlroot(this); + } +}; + +PlsqlrootContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPlsqlroot(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.PlsqlrootContext = PlsqlrootContext; + +PostgreSQLParser.prototype.plsqlroot = function() { + + var localctx = new PlsqlrootContext(this, this._ctx, this.state); + this.enterRule(localctx, 2, PostgreSQLParser.RULE_plsqlroot); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1611; + this.pl_function(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function StmtblockContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmtblock; + return this; +} + +StmtblockContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +StmtblockContext.prototype.constructor = StmtblockContext; + +StmtblockContext.prototype.stmtmulti = function() { + return this.getTypedRuleContext(StmtmultiContext,0); +}; + +StmtblockContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmtblock(this); + } +}; + +StmtblockContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmtblock(this); + } +}; + +StmtblockContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmtblock(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.StmtblockContext = StmtblockContext; + +PostgreSQLParser.prototype.stmtblock = function() { + + var localctx = new StmtblockContext(this, this._ctx, this.state); + this.enterRule(localctx, 4, PostgreSQLParser.RULE_stmtblock); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1613; + this.stmtmulti(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function StmtmultiContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmtmulti; + return this; +} + +StmtmultiContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +StmtmultiContext.prototype.constructor = StmtmultiContext; + +StmtmultiContext.prototype.stmt = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(StmtContext); + } else { + return this.getTypedRuleContext(StmtContext,i); + } +}; + +StmtmultiContext.prototype.SEMI = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.SEMI); + } else { + return this.getToken(PostgreSQLParser.SEMI, i); + } +}; + + +StmtmultiContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmtmulti(this); + } +}; + +StmtmultiContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmtmulti(this); + } +}; + +StmtmultiContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmtmulti(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.StmtmultiContext = StmtmultiContext; + +PostgreSQLParser.prototype.stmtmulti = function() { + + var localctx = new StmtmultiContext(this, this._ctx, this.state); + this.enterRule(localctx, 6, PostgreSQLParser.RULE_stmtmulti); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 1621; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.OPEN_PAREN || _la===PostgreSQLParser.ANALYSE || ((((_la - 32)) & ~0x1f) == 0 && ((1 << (_la - 32)) & ((1 << (PostgreSQLParser.ANALYZE - 32)) | (1 << (PostgreSQLParser.CREATE - 32)) | (1 << (PostgreSQLParser.DO - 32)) | (1 << (PostgreSQLParser.FETCH - 32)))) !== 0) || ((((_la - 65)) & ~0x1f) == 0 && ((1 << (_la - 65)) & ((1 << (PostgreSQLParser.GRANT - 65)) | (1 << (PostgreSQLParser.SELECT - 65)) | (1 << (PostgreSQLParser.TABLE - 65)))) !== 0) || _la===PostgreSQLParser.WITH || _la===PostgreSQLParser.ABORT_P || ((((_la - 138)) & ~0x1f) == 0 && ((1 << (_la - 138)) & ((1 << (PostgreSQLParser.ALTER - 138)) | (1 << (PostgreSQLParser.BEGIN_P - 138)) | (1 << (PostgreSQLParser.CHECKPOINT - 138)) | (1 << (PostgreSQLParser.CLOSE - 138)) | (1 << (PostgreSQLParser.CLUSTER - 138)) | (1 << (PostgreSQLParser.COMMENT - 138)) | (1 << (PostgreSQLParser.COMMIT - 138)) | (1 << (PostgreSQLParser.COPY - 138)))) !== 0) || ((((_la - 177)) & ~0x1f) == 0 && ((1 << (_la - 177)) & ((1 << (PostgreSQLParser.DEALLOCATE - 177)) | (1 << (PostgreSQLParser.DECLARE - 177)) | (1 << (PostgreSQLParser.DELETE_P - 177)) | (1 << (PostgreSQLParser.DISCARD - 177)) | (1 << (PostgreSQLParser.DROP - 177)) | (1 << (PostgreSQLParser.EXECUTE - 177)) | (1 << (PostgreSQLParser.EXPLAIN - 177)))) !== 0) || ((((_la - 232)) & ~0x1f) == 0 && ((1 << (_la - 232)) & ((1 << (PostgreSQLParser.INSERT - 232)) | (1 << (PostgreSQLParser.LISTEN - 232)) | (1 << (PostgreSQLParser.LOAD - 232)) | (1 << (PostgreSQLParser.LOCK_P - 232)) | (1 << (PostgreSQLParser.MOVE - 232)) | (1 << (PostgreSQLParser.NOTIFY - 232)))) !== 0) || ((((_la - 281)) & ~0x1f) == 0 && ((1 << (_la - 281)) & ((1 << (PostgreSQLParser.PREPARE - 281)) | (1 << (PostgreSQLParser.REASSIGN - 281)) | (1 << (PostgreSQLParser.REFRESH - 281)) | (1 << (PostgreSQLParser.REINDEX - 281)) | (1 << (PostgreSQLParser.RELEASE - 281)) | (1 << (PostgreSQLParser.RESET - 281)) | (1 << (PostgreSQLParser.REVOKE - 281)) | (1 << (PostgreSQLParser.ROLLBACK - 281)))) !== 0) || ((((_la - 313)) & ~0x1f) == 0 && ((1 << (_la - 313)) & ((1 << (PostgreSQLParser.SAVEPOINT - 313)) | (1 << (PostgreSQLParser.SECURITY - 313)) | (1 << (PostgreSQLParser.SET - 313)) | (1 << (PostgreSQLParser.SHOW - 313)) | (1 << (PostgreSQLParser.START - 313)))) !== 0) || ((((_la - 349)) & ~0x1f) == 0 && ((1 << (_la - 349)) & ((1 << (PostgreSQLParser.TRUNCATE - 349)) | (1 << (PostgreSQLParser.UNLISTEN - 349)) | (1 << (PostgreSQLParser.UPDATE - 349)) | (1 << (PostgreSQLParser.VACUUM - 349)))) !== 0) || ((((_la - 413)) & ~0x1f) == 0 && ((1 << (_la - 413)) & ((1 << (PostgreSQLParser.VALUES - 413)) | (1 << (PostgreSQLParser.CALL - 413)) | (1 << (PostgreSQLParser.IMPORT_P - 413)))) !== 0) || _la===PostgreSQLParser.END_P || _la===PostgreSQLParser.MetaCommand) { + this.state = 1615; + this.stmt(); + this.state = 1617; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.SEMI) { + this.state = 1616; + this.match(PostgreSQLParser.SEMI); + } + + this.state = 1623; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function StmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt; + return this; +} + +StmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +StmtContext.prototype.constructor = StmtContext; + +StmtContext.prototype.altereventtrigstmt = function() { + return this.getTypedRuleContext(AltereventtrigstmtContext,0); +}; + +StmtContext.prototype.altercollationstmt = function() { + return this.getTypedRuleContext(AltercollationstmtContext,0); +}; + +StmtContext.prototype.alterdatabasestmt = function() { + return this.getTypedRuleContext(AlterdatabasestmtContext,0); +}; + +StmtContext.prototype.alterdatabasesetstmt = function() { + return this.getTypedRuleContext(AlterdatabasesetstmtContext,0); +}; + +StmtContext.prototype.alterdefaultprivilegesstmt = function() { + return this.getTypedRuleContext(AlterdefaultprivilegesstmtContext,0); +}; + +StmtContext.prototype.alterdomainstmt = function() { + return this.getTypedRuleContext(AlterdomainstmtContext,0); +}; + +StmtContext.prototype.alterenumstmt = function() { + return this.getTypedRuleContext(AlterenumstmtContext,0); +}; + +StmtContext.prototype.alterextensionstmt = function() { + return this.getTypedRuleContext(AlterextensionstmtContext,0); +}; + +StmtContext.prototype.alterextensioncontentsstmt = function() { + return this.getTypedRuleContext(AlterextensioncontentsstmtContext,0); +}; + +StmtContext.prototype.alterfdwstmt = function() { + return this.getTypedRuleContext(AlterfdwstmtContext,0); +}; + +StmtContext.prototype.alterforeignserverstmt = function() { + return this.getTypedRuleContext(AlterforeignserverstmtContext,0); +}; + +StmtContext.prototype.alterfunctionstmt = function() { + return this.getTypedRuleContext(AlterfunctionstmtContext,0); +}; + +StmtContext.prototype.altergroupstmt = function() { + return this.getTypedRuleContext(AltergroupstmtContext,0); +}; + +StmtContext.prototype.alterobjectdependsstmt = function() { + return this.getTypedRuleContext(AlterobjectdependsstmtContext,0); +}; + +StmtContext.prototype.alterobjectschemastmt = function() { + return this.getTypedRuleContext(AlterobjectschemastmtContext,0); +}; + +StmtContext.prototype.alterownerstmt = function() { + return this.getTypedRuleContext(AlterownerstmtContext,0); +}; + +StmtContext.prototype.alteroperatorstmt = function() { + return this.getTypedRuleContext(AlteroperatorstmtContext,0); +}; + +StmtContext.prototype.altertypestmt = function() { + return this.getTypedRuleContext(AltertypestmtContext,0); +}; + +StmtContext.prototype.alterpolicystmt = function() { + return this.getTypedRuleContext(AlterpolicystmtContext,0); +}; + +StmtContext.prototype.alterseqstmt = function() { + return this.getTypedRuleContext(AlterseqstmtContext,0); +}; + +StmtContext.prototype.altersystemstmt = function() { + return this.getTypedRuleContext(AltersystemstmtContext,0); +}; + +StmtContext.prototype.altertablestmt = function() { + return this.getTypedRuleContext(AltertablestmtContext,0); +}; + +StmtContext.prototype.altertblspcstmt = function() { + return this.getTypedRuleContext(AltertblspcstmtContext,0); +}; + +StmtContext.prototype.altercompositetypestmt = function() { + return this.getTypedRuleContext(AltercompositetypestmtContext,0); +}; + +StmtContext.prototype.alterpublicationstmt = function() { + return this.getTypedRuleContext(AlterpublicationstmtContext,0); +}; + +StmtContext.prototype.alterrolesetstmt = function() { + return this.getTypedRuleContext(AlterrolesetstmtContext,0); +}; + +StmtContext.prototype.alterrolestmt = function() { + return this.getTypedRuleContext(AlterrolestmtContext,0); +}; + +StmtContext.prototype.altersubscriptionstmt = function() { + return this.getTypedRuleContext(AltersubscriptionstmtContext,0); +}; + +StmtContext.prototype.alterstatsstmt = function() { + return this.getTypedRuleContext(AlterstatsstmtContext,0); +}; + +StmtContext.prototype.altertsconfigurationstmt = function() { + return this.getTypedRuleContext(AltertsconfigurationstmtContext,0); +}; + +StmtContext.prototype.altertsdictionarystmt = function() { + return this.getTypedRuleContext(AltertsdictionarystmtContext,0); +}; + +StmtContext.prototype.alterusermappingstmt = function() { + return this.getTypedRuleContext(AlterusermappingstmtContext,0); +}; + +StmtContext.prototype.analyzestmt = function() { + return this.getTypedRuleContext(AnalyzestmtContext,0); +}; + +StmtContext.prototype.callstmt = function() { + return this.getTypedRuleContext(CallstmtContext,0); +}; + +StmtContext.prototype.checkpointstmt = function() { + return this.getTypedRuleContext(CheckpointstmtContext,0); +}; + +StmtContext.prototype.closeportalstmt = function() { + return this.getTypedRuleContext(CloseportalstmtContext,0); +}; + +StmtContext.prototype.clusterstmt = function() { + return this.getTypedRuleContext(ClusterstmtContext,0); +}; + +StmtContext.prototype.commentstmt = function() { + return this.getTypedRuleContext(CommentstmtContext,0); +}; + +StmtContext.prototype.constraintssetstmt = function() { + return this.getTypedRuleContext(ConstraintssetstmtContext,0); +}; + +StmtContext.prototype.copystmt = function() { + return this.getTypedRuleContext(CopystmtContext,0); +}; + +StmtContext.prototype.createamstmt = function() { + return this.getTypedRuleContext(CreateamstmtContext,0); +}; + +StmtContext.prototype.createasstmt = function() { + return this.getTypedRuleContext(CreateasstmtContext,0); +}; + +StmtContext.prototype.createassertionstmt = function() { + return this.getTypedRuleContext(CreateassertionstmtContext,0); +}; + +StmtContext.prototype.createcaststmt = function() { + return this.getTypedRuleContext(CreatecaststmtContext,0); +}; + +StmtContext.prototype.createconversionstmt = function() { + return this.getTypedRuleContext(CreateconversionstmtContext,0); +}; + +StmtContext.prototype.createdomainstmt = function() { + return this.getTypedRuleContext(CreatedomainstmtContext,0); +}; + +StmtContext.prototype.createextensionstmt = function() { + return this.getTypedRuleContext(CreateextensionstmtContext,0); +}; + +StmtContext.prototype.createfdwstmt = function() { + return this.getTypedRuleContext(CreatefdwstmtContext,0); +}; + +StmtContext.prototype.createforeignserverstmt = function() { + return this.getTypedRuleContext(CreateforeignserverstmtContext,0); +}; + +StmtContext.prototype.createforeigntablestmt = function() { + return this.getTypedRuleContext(CreateforeigntablestmtContext,0); +}; + +StmtContext.prototype.createfunctionstmt = function() { + return this.getTypedRuleContext(CreatefunctionstmtContext,0); +}; + +StmtContext.prototype.creategroupstmt = function() { + return this.getTypedRuleContext(CreategroupstmtContext,0); +}; + +StmtContext.prototype.creatematviewstmt = function() { + return this.getTypedRuleContext(CreatematviewstmtContext,0); +}; + +StmtContext.prototype.createopclassstmt = function() { + return this.getTypedRuleContext(CreateopclassstmtContext,0); +}; + +StmtContext.prototype.createopfamilystmt = function() { + return this.getTypedRuleContext(CreateopfamilystmtContext,0); +}; + +StmtContext.prototype.createpublicationstmt = function() { + return this.getTypedRuleContext(CreatepublicationstmtContext,0); +}; + +StmtContext.prototype.alteropfamilystmt = function() { + return this.getTypedRuleContext(AlteropfamilystmtContext,0); +}; + +StmtContext.prototype.createpolicystmt = function() { + return this.getTypedRuleContext(CreatepolicystmtContext,0); +}; + +StmtContext.prototype.createplangstmt = function() { + return this.getTypedRuleContext(CreateplangstmtContext,0); +}; + +StmtContext.prototype.createschemastmt = function() { + return this.getTypedRuleContext(CreateschemastmtContext,0); +}; + +StmtContext.prototype.createseqstmt = function() { + return this.getTypedRuleContext(CreateseqstmtContext,0); +}; + +StmtContext.prototype.createstmt = function() { + return this.getTypedRuleContext(CreatestmtContext,0); +}; + +StmtContext.prototype.createsubscriptionstmt = function() { + return this.getTypedRuleContext(CreatesubscriptionstmtContext,0); +}; + +StmtContext.prototype.createstatsstmt = function() { + return this.getTypedRuleContext(CreatestatsstmtContext,0); +}; + +StmtContext.prototype.createtablespacestmt = function() { + return this.getTypedRuleContext(CreatetablespacestmtContext,0); +}; + +StmtContext.prototype.createtransformstmt = function() { + return this.getTypedRuleContext(CreatetransformstmtContext,0); +}; + +StmtContext.prototype.createtrigstmt = function() { + return this.getTypedRuleContext(CreatetrigstmtContext,0); +}; + +StmtContext.prototype.createeventtrigstmt = function() { + return this.getTypedRuleContext(CreateeventtrigstmtContext,0); +}; + +StmtContext.prototype.createrolestmt = function() { + return this.getTypedRuleContext(CreaterolestmtContext,0); +}; + +StmtContext.prototype.createuserstmt = function() { + return this.getTypedRuleContext(CreateuserstmtContext,0); +}; + +StmtContext.prototype.createusermappingstmt = function() { + return this.getTypedRuleContext(CreateusermappingstmtContext,0); +}; + +StmtContext.prototype.createdbstmt = function() { + return this.getTypedRuleContext(CreatedbstmtContext,0); +}; + +StmtContext.prototype.deallocatestmt = function() { + return this.getTypedRuleContext(DeallocatestmtContext,0); +}; + +StmtContext.prototype.declarecursorstmt = function() { + return this.getTypedRuleContext(DeclarecursorstmtContext,0); +}; + +StmtContext.prototype.definestmt = function() { + return this.getTypedRuleContext(DefinestmtContext,0); +}; + +StmtContext.prototype.deletestmt = function() { + return this.getTypedRuleContext(DeletestmtContext,0); +}; + +StmtContext.prototype.discardstmt = function() { + return this.getTypedRuleContext(DiscardstmtContext,0); +}; + +StmtContext.prototype.dostmt = function() { + return this.getTypedRuleContext(DostmtContext,0); +}; + +StmtContext.prototype.dropcaststmt = function() { + return this.getTypedRuleContext(DropcaststmtContext,0); +}; + +StmtContext.prototype.dropopclassstmt = function() { + return this.getTypedRuleContext(DropopclassstmtContext,0); +}; + +StmtContext.prototype.dropopfamilystmt = function() { + return this.getTypedRuleContext(DropopfamilystmtContext,0); +}; + +StmtContext.prototype.dropownedstmt = function() { + return this.getTypedRuleContext(DropownedstmtContext,0); +}; + +StmtContext.prototype.dropstmt = function() { + return this.getTypedRuleContext(DropstmtContext,0); +}; + +StmtContext.prototype.dropsubscriptionstmt = function() { + return this.getTypedRuleContext(DropsubscriptionstmtContext,0); +}; + +StmtContext.prototype.droptablespacestmt = function() { + return this.getTypedRuleContext(DroptablespacestmtContext,0); +}; + +StmtContext.prototype.droptransformstmt = function() { + return this.getTypedRuleContext(DroptransformstmtContext,0); +}; + +StmtContext.prototype.droprolestmt = function() { + return this.getTypedRuleContext(DroprolestmtContext,0); +}; + +StmtContext.prototype.dropusermappingstmt = function() { + return this.getTypedRuleContext(DropusermappingstmtContext,0); +}; + +StmtContext.prototype.dropdbstmt = function() { + return this.getTypedRuleContext(DropdbstmtContext,0); +}; + +StmtContext.prototype.executestmt = function() { + return this.getTypedRuleContext(ExecutestmtContext,0); +}; + +StmtContext.prototype.explainstmt = function() { + return this.getTypedRuleContext(ExplainstmtContext,0); +}; + +StmtContext.prototype.fetchstmt = function() { + return this.getTypedRuleContext(FetchstmtContext,0); +}; + +StmtContext.prototype.grantstmt = function() { + return this.getTypedRuleContext(GrantstmtContext,0); +}; + +StmtContext.prototype.grantrolestmt = function() { + return this.getTypedRuleContext(GrantrolestmtContext,0); +}; + +StmtContext.prototype.importforeignschemastmt = function() { + return this.getTypedRuleContext(ImportforeignschemastmtContext,0); +}; + +StmtContext.prototype.indexstmt = function() { + return this.getTypedRuleContext(IndexstmtContext,0); +}; + +StmtContext.prototype.insertstmt = function() { + return this.getTypedRuleContext(InsertstmtContext,0); +}; + +StmtContext.prototype.listenstmt = function() { + return this.getTypedRuleContext(ListenstmtContext,0); +}; + +StmtContext.prototype.refreshmatviewstmt = function() { + return this.getTypedRuleContext(RefreshmatviewstmtContext,0); +}; + +StmtContext.prototype.loadstmt = function() { + return this.getTypedRuleContext(LoadstmtContext,0); +}; + +StmtContext.prototype.lockstmt = function() { + return this.getTypedRuleContext(LockstmtContext,0); +}; + +StmtContext.prototype.notifystmt = function() { + return this.getTypedRuleContext(NotifystmtContext,0); +}; + +StmtContext.prototype.preparestmt = function() { + return this.getTypedRuleContext(PreparestmtContext,0); +}; + +StmtContext.prototype.reassignownedstmt = function() { + return this.getTypedRuleContext(ReassignownedstmtContext,0); +}; + +StmtContext.prototype.reindexstmt = function() { + return this.getTypedRuleContext(ReindexstmtContext,0); +}; + +StmtContext.prototype.removeaggrstmt = function() { + return this.getTypedRuleContext(RemoveaggrstmtContext,0); +}; + +StmtContext.prototype.removefuncstmt = function() { + return this.getTypedRuleContext(RemovefuncstmtContext,0); +}; + +StmtContext.prototype.removeoperstmt = function() { + return this.getTypedRuleContext(RemoveoperstmtContext,0); +}; + +StmtContext.prototype.renamestmt = function() { + return this.getTypedRuleContext(RenamestmtContext,0); +}; + +StmtContext.prototype.revokestmt = function() { + return this.getTypedRuleContext(RevokestmtContext,0); +}; + +StmtContext.prototype.revokerolestmt = function() { + return this.getTypedRuleContext(RevokerolestmtContext,0); +}; + +StmtContext.prototype.rulestmt = function() { + return this.getTypedRuleContext(RulestmtContext,0); +}; + +StmtContext.prototype.seclabelstmt = function() { + return this.getTypedRuleContext(SeclabelstmtContext,0); +}; + +StmtContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +StmtContext.prototype.transactionstmt = function() { + return this.getTypedRuleContext(TransactionstmtContext,0); +}; + +StmtContext.prototype.truncatestmt = function() { + return this.getTypedRuleContext(TruncatestmtContext,0); +}; + +StmtContext.prototype.unlistenstmt = function() { + return this.getTypedRuleContext(UnlistenstmtContext,0); +}; + +StmtContext.prototype.updatestmt = function() { + return this.getTypedRuleContext(UpdatestmtContext,0); +}; + +StmtContext.prototype.vacuumstmt = function() { + return this.getTypedRuleContext(VacuumstmtContext,0); +}; + +StmtContext.prototype.variableresetstmt = function() { + return this.getTypedRuleContext(VariableresetstmtContext,0); +}; + +StmtContext.prototype.variablesetstmt = function() { + return this.getTypedRuleContext(VariablesetstmtContext,0); +}; + +StmtContext.prototype.variableshowstmt = function() { + return this.getTypedRuleContext(VariableshowstmtContext,0); +}; + +StmtContext.prototype.viewstmt = function() { + return this.getTypedRuleContext(ViewstmtContext,0); +}; + +StmtContext.prototype.plsqlconsolecommand = function() { + return this.getTypedRuleContext(PlsqlconsolecommandContext,0); +}; + +StmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt(this); + } +}; + +StmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt(this); + } +}; + +StmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.StmtContext = StmtContext; + +PostgreSQLParser.prototype.stmt = function() { + + var localctx = new StmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 8, PostgreSQLParser.RULE_stmt); + try { + this.state = 1748; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,2,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 1624; + this.altereventtrigstmt(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 1625; + this.altercollationstmt(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 1626; + this.alterdatabasestmt(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 1627; + this.alterdatabasesetstmt(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 1628; + this.alterdefaultprivilegesstmt(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 1629; + this.alterdomainstmt(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 1630; + this.alterenumstmt(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 1631; + this.alterextensionstmt(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 1632; + this.alterextensioncontentsstmt(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 1633; + this.alterfdwstmt(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 1634; + this.alterforeignserverstmt(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 1635; + this.alterfunctionstmt(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 1636; + this.altergroupstmt(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 1637; + this.alterobjectdependsstmt(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 1638; + this.alterobjectschemastmt(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 1639; + this.alterownerstmt(); + break; + + case 17: + this.enterOuterAlt(localctx, 17); + this.state = 1640; + this.alteroperatorstmt(); + break; + + case 18: + this.enterOuterAlt(localctx, 18); + this.state = 1641; + this.altertypestmt(); + break; + + case 19: + this.enterOuterAlt(localctx, 19); + this.state = 1642; + this.alterpolicystmt(); + break; + + case 20: + this.enterOuterAlt(localctx, 20); + this.state = 1643; + this.alterseqstmt(); + break; + + case 21: + this.enterOuterAlt(localctx, 21); + this.state = 1644; + this.altersystemstmt(); + break; + + case 22: + this.enterOuterAlt(localctx, 22); + this.state = 1645; + this.altertablestmt(); + break; + + case 23: + this.enterOuterAlt(localctx, 23); + this.state = 1646; + this.altertblspcstmt(); + break; + + case 24: + this.enterOuterAlt(localctx, 24); + this.state = 1647; + this.altercompositetypestmt(); + break; + + case 25: + this.enterOuterAlt(localctx, 25); + this.state = 1648; + this.alterpublicationstmt(); + break; + + case 26: + this.enterOuterAlt(localctx, 26); + this.state = 1649; + this.alterrolesetstmt(); + break; + + case 27: + this.enterOuterAlt(localctx, 27); + this.state = 1650; + this.alterrolestmt(); + break; + + case 28: + this.enterOuterAlt(localctx, 28); + this.state = 1651; + this.altersubscriptionstmt(); + break; + + case 29: + this.enterOuterAlt(localctx, 29); + this.state = 1652; + this.alterstatsstmt(); + break; + + case 30: + this.enterOuterAlt(localctx, 30); + this.state = 1653; + this.altertsconfigurationstmt(); + break; + + case 31: + this.enterOuterAlt(localctx, 31); + this.state = 1654; + this.altertsdictionarystmt(); + break; + + case 32: + this.enterOuterAlt(localctx, 32); + this.state = 1655; + this.alterusermappingstmt(); + break; + + case 33: + this.enterOuterAlt(localctx, 33); + this.state = 1656; + this.analyzestmt(); + break; + + case 34: + this.enterOuterAlt(localctx, 34); + this.state = 1657; + this.callstmt(); + break; + + case 35: + this.enterOuterAlt(localctx, 35); + this.state = 1658; + this.checkpointstmt(); + break; + + case 36: + this.enterOuterAlt(localctx, 36); + this.state = 1659; + this.closeportalstmt(); + break; + + case 37: + this.enterOuterAlt(localctx, 37); + this.state = 1660; + this.clusterstmt(); + break; + + case 38: + this.enterOuterAlt(localctx, 38); + this.state = 1661; + this.commentstmt(); + break; + + case 39: + this.enterOuterAlt(localctx, 39); + this.state = 1662; + this.constraintssetstmt(); + break; + + case 40: + this.enterOuterAlt(localctx, 40); + this.state = 1663; + this.copystmt(); + break; + + case 41: + this.enterOuterAlt(localctx, 41); + this.state = 1664; + this.createamstmt(); + break; + + case 42: + this.enterOuterAlt(localctx, 42); + this.state = 1665; + this.createasstmt(); + break; + + case 43: + this.enterOuterAlt(localctx, 43); + this.state = 1666; + this.createassertionstmt(); + break; + + case 44: + this.enterOuterAlt(localctx, 44); + this.state = 1667; + this.createcaststmt(); + break; + + case 45: + this.enterOuterAlt(localctx, 45); + this.state = 1668; + this.createconversionstmt(); + break; + + case 46: + this.enterOuterAlt(localctx, 46); + this.state = 1669; + this.createdomainstmt(); + break; + + case 47: + this.enterOuterAlt(localctx, 47); + this.state = 1670; + this.createextensionstmt(); + break; + + case 48: + this.enterOuterAlt(localctx, 48); + this.state = 1671; + this.createfdwstmt(); + break; + + case 49: + this.enterOuterAlt(localctx, 49); + this.state = 1672; + this.createforeignserverstmt(); + break; + + case 50: + this.enterOuterAlt(localctx, 50); + this.state = 1673; + this.createforeigntablestmt(); + break; + + case 51: + this.enterOuterAlt(localctx, 51); + this.state = 1674; + this.createfunctionstmt(); + break; + + case 52: + this.enterOuterAlt(localctx, 52); + this.state = 1675; + this.creategroupstmt(); + break; + + case 53: + this.enterOuterAlt(localctx, 53); + this.state = 1676; + this.creatematviewstmt(); + break; + + case 54: + this.enterOuterAlt(localctx, 54); + this.state = 1677; + this.createopclassstmt(); + break; + + case 55: + this.enterOuterAlt(localctx, 55); + this.state = 1678; + this.createopfamilystmt(); + break; + + case 56: + this.enterOuterAlt(localctx, 56); + this.state = 1679; + this.createpublicationstmt(); + break; + + case 57: + this.enterOuterAlt(localctx, 57); + this.state = 1680; + this.alteropfamilystmt(); + break; + + case 58: + this.enterOuterAlt(localctx, 58); + this.state = 1681; + this.createpolicystmt(); + break; + + case 59: + this.enterOuterAlt(localctx, 59); + this.state = 1682; + this.createplangstmt(); + break; + + case 60: + this.enterOuterAlt(localctx, 60); + this.state = 1683; + this.createschemastmt(); + break; + + case 61: + this.enterOuterAlt(localctx, 61); + this.state = 1684; + this.createseqstmt(); + break; + + case 62: + this.enterOuterAlt(localctx, 62); + this.state = 1685; + this.createstmt(); + break; + + case 63: + this.enterOuterAlt(localctx, 63); + this.state = 1686; + this.createsubscriptionstmt(); + break; + + case 64: + this.enterOuterAlt(localctx, 64); + this.state = 1687; + this.createstatsstmt(); + break; + + case 65: + this.enterOuterAlt(localctx, 65); + this.state = 1688; + this.createtablespacestmt(); + break; + + case 66: + this.enterOuterAlt(localctx, 66); + this.state = 1689; + this.createtransformstmt(); + break; + + case 67: + this.enterOuterAlt(localctx, 67); + this.state = 1690; + this.createtrigstmt(); + break; + + case 68: + this.enterOuterAlt(localctx, 68); + this.state = 1691; + this.createeventtrigstmt(); + break; + + case 69: + this.enterOuterAlt(localctx, 69); + this.state = 1692; + this.createrolestmt(); + break; + + case 70: + this.enterOuterAlt(localctx, 70); + this.state = 1693; + this.createuserstmt(); + break; + + case 71: + this.enterOuterAlt(localctx, 71); + this.state = 1694; + this.createusermappingstmt(); + break; + + case 72: + this.enterOuterAlt(localctx, 72); + this.state = 1695; + this.createdbstmt(); + break; + + case 73: + this.enterOuterAlt(localctx, 73); + this.state = 1696; + this.deallocatestmt(); + break; + + case 74: + this.enterOuterAlt(localctx, 74); + this.state = 1697; + this.declarecursorstmt(); + break; + + case 75: + this.enterOuterAlt(localctx, 75); + this.state = 1698; + this.definestmt(); + break; + + case 76: + this.enterOuterAlt(localctx, 76); + this.state = 1699; + this.deletestmt(); + break; + + case 77: + this.enterOuterAlt(localctx, 77); + this.state = 1700; + this.discardstmt(); + break; + + case 78: + this.enterOuterAlt(localctx, 78); + this.state = 1701; + this.dostmt(); + break; + + case 79: + this.enterOuterAlt(localctx, 79); + this.state = 1702; + this.dropcaststmt(); + break; + + case 80: + this.enterOuterAlt(localctx, 80); + this.state = 1703; + this.dropopclassstmt(); + break; + + case 81: + this.enterOuterAlt(localctx, 81); + this.state = 1704; + this.dropopfamilystmt(); + break; + + case 82: + this.enterOuterAlt(localctx, 82); + this.state = 1705; + this.dropownedstmt(); + break; + + case 83: + this.enterOuterAlt(localctx, 83); + this.state = 1706; + this.dropstmt(); + break; + + case 84: + this.enterOuterAlt(localctx, 84); + this.state = 1707; + this.dropsubscriptionstmt(); + break; + + case 85: + this.enterOuterAlt(localctx, 85); + this.state = 1708; + this.droptablespacestmt(); + break; + + case 86: + this.enterOuterAlt(localctx, 86); + this.state = 1709; + this.droptransformstmt(); + break; + + case 87: + this.enterOuterAlt(localctx, 87); + this.state = 1710; + this.droprolestmt(); + break; + + case 88: + this.enterOuterAlt(localctx, 88); + this.state = 1711; + this.dropusermappingstmt(); + break; + + case 89: + this.enterOuterAlt(localctx, 89); + this.state = 1712; + this.dropdbstmt(); + break; + + case 90: + this.enterOuterAlt(localctx, 90); + this.state = 1713; + this.executestmt(); + break; + + case 91: + this.enterOuterAlt(localctx, 91); + this.state = 1714; + this.explainstmt(); + break; + + case 92: + this.enterOuterAlt(localctx, 92); + this.state = 1715; + this.fetchstmt(); + break; + + case 93: + this.enterOuterAlt(localctx, 93); + this.state = 1716; + this.grantstmt(); + break; + + case 94: + this.enterOuterAlt(localctx, 94); + this.state = 1717; + this.grantrolestmt(); + break; + + case 95: + this.enterOuterAlt(localctx, 95); + this.state = 1718; + this.importforeignschemastmt(); + break; + + case 96: + this.enterOuterAlt(localctx, 96); + this.state = 1719; + this.indexstmt(); + break; + + case 97: + this.enterOuterAlt(localctx, 97); + this.state = 1720; + this.insertstmt(); + break; + + case 98: + this.enterOuterAlt(localctx, 98); + this.state = 1721; + this.listenstmt(); + break; + + case 99: + this.enterOuterAlt(localctx, 99); + this.state = 1722; + this.refreshmatviewstmt(); + break; + + case 100: + this.enterOuterAlt(localctx, 100); + this.state = 1723; + this.loadstmt(); + break; + + case 101: + this.enterOuterAlt(localctx, 101); + this.state = 1724; + this.lockstmt(); + break; + + case 102: + this.enterOuterAlt(localctx, 102); + this.state = 1725; + this.notifystmt(); + break; + + case 103: + this.enterOuterAlt(localctx, 103); + this.state = 1726; + this.preparestmt(); + break; + + case 104: + this.enterOuterAlt(localctx, 104); + this.state = 1727; + this.reassignownedstmt(); + break; + + case 105: + this.enterOuterAlt(localctx, 105); + this.state = 1728; + this.reindexstmt(); + break; + + case 106: + this.enterOuterAlt(localctx, 106); + this.state = 1729; + this.removeaggrstmt(); + break; + + case 107: + this.enterOuterAlt(localctx, 107); + this.state = 1730; + this.removefuncstmt(); + break; + + case 108: + this.enterOuterAlt(localctx, 108); + this.state = 1731; + this.removeoperstmt(); + break; + + case 109: + this.enterOuterAlt(localctx, 109); + this.state = 1732; + this.renamestmt(); + break; + + case 110: + this.enterOuterAlt(localctx, 110); + this.state = 1733; + this.revokestmt(); + break; + + case 111: + this.enterOuterAlt(localctx, 111); + this.state = 1734; + this.revokerolestmt(); + break; + + case 112: + this.enterOuterAlt(localctx, 112); + this.state = 1735; + this.rulestmt(); + break; + + case 113: + this.enterOuterAlt(localctx, 113); + this.state = 1736; + this.seclabelstmt(); + break; + + case 114: + this.enterOuterAlt(localctx, 114); + this.state = 1737; + this.selectstmt(); + break; + + case 115: + this.enterOuterAlt(localctx, 115); + this.state = 1738; + this.transactionstmt(); + break; + + case 116: + this.enterOuterAlt(localctx, 116); + this.state = 1739; + this.truncatestmt(); + break; + + case 117: + this.enterOuterAlt(localctx, 117); + this.state = 1740; + this.unlistenstmt(); + break; + + case 118: + this.enterOuterAlt(localctx, 118); + this.state = 1741; + this.updatestmt(); + break; + + case 119: + this.enterOuterAlt(localctx, 119); + this.state = 1742; + this.vacuumstmt(); + break; + + case 120: + this.enterOuterAlt(localctx, 120); + this.state = 1743; + this.variableresetstmt(); + break; + + case 121: + this.enterOuterAlt(localctx, 121); + this.state = 1744; + this.variablesetstmt(); + break; + + case 122: + this.enterOuterAlt(localctx, 122); + this.state = 1745; + this.variableshowstmt(); + break; + + case 123: + this.enterOuterAlt(localctx, 123); + this.state = 1746; + this.viewstmt(); + break; + + case 124: + this.enterOuterAlt(localctx, 124); + this.state = 1747; + this.plsqlconsolecommand(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function PlsqlconsolecommandContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_plsqlconsolecommand; + return this; +} + +PlsqlconsolecommandContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +PlsqlconsolecommandContext.prototype.constructor = PlsqlconsolecommandContext; + +PlsqlconsolecommandContext.prototype.MetaCommand = function() { + return this.getToken(PostgreSQLParser.MetaCommand, 0); +}; + +PlsqlconsolecommandContext.prototype.EndMetaCommand = function() { + return this.getToken(PostgreSQLParser.EndMetaCommand, 0); +}; + +PlsqlconsolecommandContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPlsqlconsolecommand(this); + } +}; + +PlsqlconsolecommandContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPlsqlconsolecommand(this); + } +}; + +PlsqlconsolecommandContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPlsqlconsolecommand(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.PlsqlconsolecommandContext = PlsqlconsolecommandContext; + +PostgreSQLParser.prototype.plsqlconsolecommand = function() { + + var localctx = new PlsqlconsolecommandContext(this, this._ctx, this.state); + this.enterRule(localctx, 10, PostgreSQLParser.RULE_plsqlconsolecommand); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 1750; + this.match(PostgreSQLParser.MetaCommand); + this.state = 1752; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.EndMetaCommand) { + this.state = 1751; + this.match(PostgreSQLParser.EndMetaCommand); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CallstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_callstmt; + return this; +} + +CallstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CallstmtContext.prototype.constructor = CallstmtContext; + +CallstmtContext.prototype.CALL = function() { + return this.getToken(PostgreSQLParser.CALL, 0); +}; + +CallstmtContext.prototype.func_application = function() { + return this.getTypedRuleContext(Func_applicationContext,0); +}; + +CallstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCallstmt(this); + } +}; + +CallstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCallstmt(this); + } +}; + +CallstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCallstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CallstmtContext = CallstmtContext; + +PostgreSQLParser.prototype.callstmt = function() { + + var localctx = new CallstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 12, PostgreSQLParser.RULE_callstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1754; + this.match(PostgreSQLParser.CALL); + this.state = 1755; + this.func_application(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreaterolestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createrolestmt; + return this; +} + +CreaterolestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreaterolestmtContext.prototype.constructor = CreaterolestmtContext; + +CreaterolestmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreaterolestmtContext.prototype.ROLE = function() { + return this.getToken(PostgreSQLParser.ROLE, 0); +}; + +CreaterolestmtContext.prototype.roleid = function() { + return this.getTypedRuleContext(RoleidContext,0); +}; + +CreaterolestmtContext.prototype.opt_with = function() { + return this.getTypedRuleContext(Opt_withContext,0); +}; + +CreaterolestmtContext.prototype.optrolelist = function() { + return this.getTypedRuleContext(OptrolelistContext,0); +}; + +CreaterolestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreaterolestmt(this); + } +}; + +CreaterolestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreaterolestmt(this); + } +}; + +CreaterolestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreaterolestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreaterolestmtContext = CreaterolestmtContext; + +PostgreSQLParser.prototype.createrolestmt = function() { + + var localctx = new CreaterolestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 14, PostgreSQLParser.RULE_createrolestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1757; + this.match(PostgreSQLParser.CREATE); + this.state = 1758; + this.match(PostgreSQLParser.ROLE); + this.state = 1759; + this.roleid(); + this.state = 1760; + this.opt_with(); + this.state = 1761; + this.optrolelist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_withContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_with; + return this; +} + +Opt_withContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_withContext.prototype.constructor = Opt_withContext; + +Opt_withContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Opt_withContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_with(this); + } +}; + +Opt_withContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_with(this); + } +}; + +Opt_withContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_with(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_withContext = Opt_withContext; + +PostgreSQLParser.prototype.opt_with = function() { + + var localctx = new Opt_withContext(this, this._ctx, this.state); + this.enterRule(localctx, 16, PostgreSQLParser.RULE_opt_with); + try { + this.state = 1765; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,4,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 1763; + this.match(PostgreSQLParser.WITH); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptrolelistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optrolelist; + return this; +} + +OptrolelistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptrolelistContext.prototype.constructor = OptrolelistContext; + +OptrolelistContext.prototype.createoptroleelem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(CreateoptroleelemContext); + } else { + return this.getTypedRuleContext(CreateoptroleelemContext,i); + } +}; + +OptrolelistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptrolelist(this); + } +}; + +OptrolelistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptrolelist(this); + } +}; + +OptrolelistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptrolelist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptrolelistContext = OptrolelistContext; + +PostgreSQLParser.prototype.optrolelist = function() { + + var localctx = new OptrolelistContext(this, this._ctx, this.state); + this.enterRule(localctx, 18, PostgreSQLParser.RULE_optrolelist); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1770; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,5,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 1767; + this.createoptroleelem(); + } + this.state = 1772; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,5,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlteroptrolelistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alteroptrolelist; + return this; +} + +AlteroptrolelistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlteroptrolelistContext.prototype.constructor = AlteroptrolelistContext; + +AlteroptrolelistContext.prototype.alteroptroleelem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(AlteroptroleelemContext); + } else { + return this.getTypedRuleContext(AlteroptroleelemContext,i); + } +}; + +AlteroptrolelistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlteroptrolelist(this); + } +}; + +AlteroptrolelistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlteroptrolelist(this); + } +}; + +AlteroptrolelistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlteroptrolelist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlteroptrolelistContext = AlteroptrolelistContext; + +PostgreSQLParser.prototype.alteroptrolelist = function() { + + var localctx = new AlteroptrolelistContext(this, this._ctx, this.state); + this.enterRule(localctx, 20, PostgreSQLParser.RULE_alteroptrolelist); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1776; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,6,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 1773; + this.alteroptroleelem(); + } + this.state = 1778; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,6,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlteroptroleelemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alteroptroleelem; + return this; +} + +AlteroptroleelemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlteroptroleelemContext.prototype.constructor = AlteroptroleelemContext; + +AlteroptroleelemContext.prototype.PASSWORD = function() { + return this.getToken(PostgreSQLParser.PASSWORD, 0); +}; + +AlteroptroleelemContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +AlteroptroleelemContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +AlteroptroleelemContext.prototype.ENCRYPTED = function() { + return this.getToken(PostgreSQLParser.ENCRYPTED, 0); +}; + +AlteroptroleelemContext.prototype.UNENCRYPTED = function() { + return this.getToken(PostgreSQLParser.UNENCRYPTED, 0); +}; + +AlteroptroleelemContext.prototype.INHERIT = function() { + return this.getToken(PostgreSQLParser.INHERIT, 0); +}; + +AlteroptroleelemContext.prototype.CONNECTION = function() { + return this.getToken(PostgreSQLParser.CONNECTION, 0); +}; + +AlteroptroleelemContext.prototype.LIMIT = function() { + return this.getToken(PostgreSQLParser.LIMIT, 0); +}; + +AlteroptroleelemContext.prototype.signediconst = function() { + return this.getTypedRuleContext(SignediconstContext,0); +}; + +AlteroptroleelemContext.prototype.VALID = function() { + return this.getToken(PostgreSQLParser.VALID, 0); +}; + +AlteroptroleelemContext.prototype.UNTIL = function() { + return this.getToken(PostgreSQLParser.UNTIL, 0); +}; + +AlteroptroleelemContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +AlteroptroleelemContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +AlteroptroleelemContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +AlteroptroleelemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlteroptroleelem(this); + } +}; + +AlteroptroleelemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlteroptroleelem(this); + } +}; + +AlteroptroleelemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlteroptroleelem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlteroptroleelemContext = AlteroptroleelemContext; + +PostgreSQLParser.prototype.alteroptroleelem = function() { + + var localctx = new AlteroptroleelemContext(this, this._ctx, this.state); + this.enterRule(localctx, 22, PostgreSQLParser.RULE_alteroptroleelem); + var _la = 0; // Token type + try { + this.state = 1797; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.PASSWORD: + this.enterOuterAlt(localctx, 1); + this.state = 1779; + this.match(PostgreSQLParser.PASSWORD); + this.state = 1782; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.state = 1780; + this.sconst(); + break; + case PostgreSQLParser.NULL_P: + this.state = 1781; + this.match(PostgreSQLParser.NULL_P); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.UNENCRYPTED: + this.enterOuterAlt(localctx, 2); + this.state = 1784; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.ENCRYPTED || _la===PostgreSQLParser.UNENCRYPTED)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1785; + this.match(PostgreSQLParser.PASSWORD); + this.state = 1786; + this.sconst(); + break; + case PostgreSQLParser.INHERIT: + this.enterOuterAlt(localctx, 3); + this.state = 1787; + this.match(PostgreSQLParser.INHERIT); + break; + case PostgreSQLParser.CONNECTION: + this.enterOuterAlt(localctx, 4); + this.state = 1788; + this.match(PostgreSQLParser.CONNECTION); + this.state = 1789; + this.match(PostgreSQLParser.LIMIT); + this.state = 1790; + this.signediconst(); + break; + case PostgreSQLParser.VALID: + this.enterOuterAlt(localctx, 5); + this.state = 1791; + this.match(PostgreSQLParser.VALID); + this.state = 1792; + this.match(PostgreSQLParser.UNTIL); + this.state = 1793; + this.sconst(); + break; + case PostgreSQLParser.USER: + this.enterOuterAlt(localctx, 6); + this.state = 1794; + this.match(PostgreSQLParser.USER); + this.state = 1795; + this.role_list(); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RESET: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SET: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 7); + this.state = 1796; + this.identifier(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateoptroleelemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createoptroleelem; + return this; +} + +CreateoptroleelemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateoptroleelemContext.prototype.constructor = CreateoptroleelemContext; + +CreateoptroleelemContext.prototype.alteroptroleelem = function() { + return this.getTypedRuleContext(AlteroptroleelemContext,0); +}; + +CreateoptroleelemContext.prototype.SYSID = function() { + return this.getToken(PostgreSQLParser.SYSID, 0); +}; + +CreateoptroleelemContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +CreateoptroleelemContext.prototype.ADMIN = function() { + return this.getToken(PostgreSQLParser.ADMIN, 0); +}; + +CreateoptroleelemContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +CreateoptroleelemContext.prototype.ROLE = function() { + return this.getToken(PostgreSQLParser.ROLE, 0); +}; + +CreateoptroleelemContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +CreateoptroleelemContext.prototype.GROUP_P = function() { + return this.getToken(PostgreSQLParser.GROUP_P, 0); +}; + +CreateoptroleelemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateoptroleelem(this); + } +}; + +CreateoptroleelemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateoptroleelem(this); + } +}; + +CreateoptroleelemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateoptroleelem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateoptroleelemContext = CreateoptroleelemContext; + +PostgreSQLParser.prototype.createoptroleelem = function() { + + var localctx = new CreateoptroleelemContext(this, this._ctx, this.state); + this.enterRule(localctx, 24, PostgreSQLParser.RULE_createoptroleelem); + var _la = 0; // Token type + try { + this.state = 1809; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.USER: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RESET: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SET: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.VALID: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 1799; + this.alteroptroleelem(); + break; + case PostgreSQLParser.SYSID: + this.enterOuterAlt(localctx, 2); + this.state = 1800; + this.match(PostgreSQLParser.SYSID); + this.state = 1801; + this.iconst(); + break; + case PostgreSQLParser.ADMIN: + this.enterOuterAlt(localctx, 3); + this.state = 1802; + this.match(PostgreSQLParser.ADMIN); + this.state = 1803; + this.role_list(); + break; + case PostgreSQLParser.ROLE: + this.enterOuterAlt(localctx, 4); + this.state = 1804; + this.match(PostgreSQLParser.ROLE); + this.state = 1805; + this.role_list(); + break; + case PostgreSQLParser.IN_P: + this.enterOuterAlt(localctx, 5); + this.state = 1806; + this.match(PostgreSQLParser.IN_P); + this.state = 1807; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.GROUP_P || _la===PostgreSQLParser.ROLE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1808; + this.role_list(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateuserstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createuserstmt; + return this; +} + +CreateuserstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateuserstmtContext.prototype.constructor = CreateuserstmtContext; + +CreateuserstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateuserstmtContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +CreateuserstmtContext.prototype.roleid = function() { + return this.getTypedRuleContext(RoleidContext,0); +}; + +CreateuserstmtContext.prototype.opt_with = function() { + return this.getTypedRuleContext(Opt_withContext,0); +}; + +CreateuserstmtContext.prototype.optrolelist = function() { + return this.getTypedRuleContext(OptrolelistContext,0); +}; + +CreateuserstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateuserstmt(this); + } +}; + +CreateuserstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateuserstmt(this); + } +}; + +CreateuserstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateuserstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateuserstmtContext = CreateuserstmtContext; + +PostgreSQLParser.prototype.createuserstmt = function() { + + var localctx = new CreateuserstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 26, PostgreSQLParser.RULE_createuserstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1811; + this.match(PostgreSQLParser.CREATE); + this.state = 1812; + this.match(PostgreSQLParser.USER); + this.state = 1813; + this.roleid(); + this.state = 1814; + this.opt_with(); + this.state = 1815; + this.optrolelist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterrolestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterrolestmt; + return this; +} + +AlterrolestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterrolestmtContext.prototype.constructor = AlterrolestmtContext; + +AlterrolestmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterrolestmtContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +AlterrolestmtContext.prototype.opt_with = function() { + return this.getTypedRuleContext(Opt_withContext,0); +}; + +AlterrolestmtContext.prototype.alteroptrolelist = function() { + return this.getTypedRuleContext(AlteroptrolelistContext,0); +}; + +AlterrolestmtContext.prototype.ROLE = function() { + return this.getToken(PostgreSQLParser.ROLE, 0); +}; + +AlterrolestmtContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +AlterrolestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterrolestmt(this); + } +}; + +AlterrolestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterrolestmt(this); + } +}; + +AlterrolestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterrolestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterrolestmtContext = AlterrolestmtContext; + +PostgreSQLParser.prototype.alterrolestmt = function() { + + var localctx = new AlterrolestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 28, PostgreSQLParser.RULE_alterrolestmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 1817; + this.match(PostgreSQLParser.ALTER); + this.state = 1818; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.USER || _la===PostgreSQLParser.ROLE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1819; + this.rolespec(); + this.state = 1820; + this.opt_with(); + this.state = 1821; + this.alteroptrolelist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_in_databaseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_in_database; + return this; +} + +Opt_in_databaseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_in_databaseContext.prototype.constructor = Opt_in_databaseContext; + +Opt_in_databaseContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +Opt_in_databaseContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +Opt_in_databaseContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Opt_in_databaseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_in_database(this); + } +}; + +Opt_in_databaseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_in_database(this); + } +}; + +Opt_in_databaseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_in_database(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_in_databaseContext = Opt_in_databaseContext; + +PostgreSQLParser.prototype.opt_in_database = function() { + + var localctx = new Opt_in_databaseContext(this, this._ctx, this.state); + this.enterRule(localctx, 30, PostgreSQLParser.RULE_opt_in_database); + try { + this.state = 1827; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.RESET: + case PostgreSQLParser.SET: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.IN_P: + this.enterOuterAlt(localctx, 2); + this.state = 1824; + this.match(PostgreSQLParser.IN_P); + this.state = 1825; + this.match(PostgreSQLParser.DATABASE); + this.state = 1826; + this.name(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterrolesetstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterrolesetstmt; + return this; +} + +AlterrolesetstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterrolesetstmtContext.prototype.constructor = AlterrolesetstmtContext; + +AlterrolesetstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterrolesetstmtContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +AlterrolesetstmtContext.prototype.opt_in_database = function() { + return this.getTypedRuleContext(Opt_in_databaseContext,0); +}; + +AlterrolesetstmtContext.prototype.setresetclause = function() { + return this.getTypedRuleContext(SetresetclauseContext,0); +}; + +AlterrolesetstmtContext.prototype.ROLE = function() { + return this.getToken(PostgreSQLParser.ROLE, 0); +}; + +AlterrolesetstmtContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +AlterrolesetstmtContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +AlterrolesetstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterrolesetstmt(this); + } +}; + +AlterrolesetstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterrolesetstmt(this); + } +}; + +AlterrolesetstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterrolesetstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterrolesetstmtContext = AlterrolesetstmtContext; + +PostgreSQLParser.prototype.alterrolesetstmt = function() { + + var localctx = new AlterrolesetstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 32, PostgreSQLParser.RULE_alterrolesetstmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 1829; + this.match(PostgreSQLParser.ALTER); + this.state = 1830; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.USER || _la===PostgreSQLParser.ROLE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1832; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.ALL) { + this.state = 1831; + this.match(PostgreSQLParser.ALL); + } + + this.state = 1834; + this.rolespec(); + this.state = 1835; + this.opt_in_database(); + this.state = 1836; + this.setresetclause(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DroprolestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_droprolestmt; + return this; +} + +DroprolestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DroprolestmtContext.prototype.constructor = DroprolestmtContext; + +DroprolestmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DroprolestmtContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +DroprolestmtContext.prototype.ROLE = function() { + return this.getToken(PostgreSQLParser.ROLE, 0); +}; + +DroprolestmtContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +DroprolestmtContext.prototype.GROUP_P = function() { + return this.getToken(PostgreSQLParser.GROUP_P, 0); +}; + +DroprolestmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +DroprolestmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +DroprolestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDroprolestmt(this); + } +}; + +DroprolestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDroprolestmt(this); + } +}; + +DroprolestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDroprolestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DroprolestmtContext = DroprolestmtContext; + +PostgreSQLParser.prototype.droprolestmt = function() { + + var localctx = new DroprolestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 34, PostgreSQLParser.RULE_droprolestmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 1838; + this.match(PostgreSQLParser.DROP); + this.state = 1839; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.GROUP_P || _la===PostgreSQLParser.USER || _la===PostgreSQLParser.ROLE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1842; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,12,this._ctx); + if(la_===1) { + this.state = 1840; + this.match(PostgreSQLParser.IF_P); + this.state = 1841; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 1844; + this.role_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreategroupstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_creategroupstmt; + return this; +} + +CreategroupstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreategroupstmtContext.prototype.constructor = CreategroupstmtContext; + +CreategroupstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreategroupstmtContext.prototype.GROUP_P = function() { + return this.getToken(PostgreSQLParser.GROUP_P, 0); +}; + +CreategroupstmtContext.prototype.roleid = function() { + return this.getTypedRuleContext(RoleidContext,0); +}; + +CreategroupstmtContext.prototype.opt_with = function() { + return this.getTypedRuleContext(Opt_withContext,0); +}; + +CreategroupstmtContext.prototype.optrolelist = function() { + return this.getTypedRuleContext(OptrolelistContext,0); +}; + +CreategroupstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreategroupstmt(this); + } +}; + +CreategroupstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreategroupstmt(this); + } +}; + +CreategroupstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreategroupstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreategroupstmtContext = CreategroupstmtContext; + +PostgreSQLParser.prototype.creategroupstmt = function() { + + var localctx = new CreategroupstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 36, PostgreSQLParser.RULE_creategroupstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1846; + this.match(PostgreSQLParser.CREATE); + this.state = 1847; + this.match(PostgreSQLParser.GROUP_P); + this.state = 1848; + this.roleid(); + this.state = 1849; + this.opt_with(); + this.state = 1850; + this.optrolelist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltergroupstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altergroupstmt; + return this; +} + +AltergroupstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltergroupstmtContext.prototype.constructor = AltergroupstmtContext; + +AltergroupstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AltergroupstmtContext.prototype.GROUP_P = function() { + return this.getToken(PostgreSQLParser.GROUP_P, 0); +}; + +AltergroupstmtContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +AltergroupstmtContext.prototype.add_drop = function() { + return this.getTypedRuleContext(Add_dropContext,0); +}; + +AltergroupstmtContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +AltergroupstmtContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +AltergroupstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltergroupstmt(this); + } +}; + +AltergroupstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltergroupstmt(this); + } +}; + +AltergroupstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltergroupstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltergroupstmtContext = AltergroupstmtContext; + +PostgreSQLParser.prototype.altergroupstmt = function() { + + var localctx = new AltergroupstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 38, PostgreSQLParser.RULE_altergroupstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1852; + this.match(PostgreSQLParser.ALTER); + this.state = 1853; + this.match(PostgreSQLParser.GROUP_P); + this.state = 1854; + this.rolespec(); + this.state = 1855; + this.add_drop(); + this.state = 1856; + this.match(PostgreSQLParser.USER); + this.state = 1857; + this.role_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Add_dropContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_add_drop; + return this; +} + +Add_dropContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Add_dropContext.prototype.constructor = Add_dropContext; + +Add_dropContext.prototype.ADD_P = function() { + return this.getToken(PostgreSQLParser.ADD_P, 0); +}; + +Add_dropContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +Add_dropContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAdd_drop(this); + } +}; + +Add_dropContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAdd_drop(this); + } +}; + +Add_dropContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAdd_drop(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Add_dropContext = Add_dropContext; + +PostgreSQLParser.prototype.add_drop = function() { + + var localctx = new Add_dropContext(this, this._ctx, this.state); + this.enterRule(localctx, 40, PostgreSQLParser.RULE_add_drop); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 1859; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.ADD_P || _la===PostgreSQLParser.DROP)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateschemastmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createschemastmt; + return this; +} + +CreateschemastmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateschemastmtContext.prototype.constructor = CreateschemastmtContext; + +CreateschemastmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateschemastmtContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +CreateschemastmtContext.prototype.optschemaeltlist = function() { + return this.getTypedRuleContext(OptschemaeltlistContext,0); +}; + +CreateschemastmtContext.prototype.optschemaname = function() { + return this.getTypedRuleContext(OptschemanameContext,0); +}; + +CreateschemastmtContext.prototype.AUTHORIZATION = function() { + return this.getToken(PostgreSQLParser.AUTHORIZATION, 0); +}; + +CreateschemastmtContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +CreateschemastmtContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +CreateschemastmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +CreateschemastmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +CreateschemastmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +CreateschemastmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateschemastmt(this); + } +}; + +CreateschemastmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateschemastmt(this); + } +}; + +CreateschemastmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateschemastmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateschemastmtContext = CreateschemastmtContext; + +PostgreSQLParser.prototype.createschemastmt = function() { + + var localctx = new CreateschemastmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 42, PostgreSQLParser.RULE_createschemastmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1861; + this.match(PostgreSQLParser.CREATE); + this.state = 1862; + this.match(PostgreSQLParser.SCHEMA); + this.state = 1866; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,13,this._ctx); + if(la_===1) { + this.state = 1863; + this.match(PostgreSQLParser.IF_P); + this.state = 1864; + this.match(PostgreSQLParser.NOT); + this.state = 1865; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 1873; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,14,this._ctx); + switch(la_) { + case 1: + this.state = 1868; + this.optschemaname(); + this.state = 1869; + this.match(PostgreSQLParser.AUTHORIZATION); + this.state = 1870; + this.rolespec(); + break; + + case 2: + this.state = 1872; + this.colid(); + break; + + } + this.state = 1875; + this.optschemaeltlist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptschemanameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optschemaname; + return this; +} + +OptschemanameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptschemanameContext.prototype.constructor = OptschemanameContext; + +OptschemanameContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +OptschemanameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptschemaname(this); + } +}; + +OptschemanameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptschemaname(this); + } +}; + +OptschemanameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptschemaname(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptschemanameContext = OptschemanameContext; + +PostgreSQLParser.prototype.optschemaname = function() { + + var localctx = new OptschemanameContext(this, this._ctx, this.state); + this.enterRule(localctx, 44, PostgreSQLParser.RULE_optschemaname); + try { + this.state = 1879; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 1877; + this.colid(); + break; + case PostgreSQLParser.AUTHORIZATION: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptschemaeltlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optschemaeltlist; + return this; +} + +OptschemaeltlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptschemaeltlistContext.prototype.constructor = OptschemaeltlistContext; + +OptschemaeltlistContext.prototype.schema_stmt = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Schema_stmtContext); + } else { + return this.getTypedRuleContext(Schema_stmtContext,i); + } +}; + +OptschemaeltlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptschemaeltlist(this); + } +}; + +OptschemaeltlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptschemaeltlist(this); + } +}; + +OptschemaeltlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptschemaeltlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptschemaeltlistContext = OptschemaeltlistContext; + +PostgreSQLParser.prototype.optschemaeltlist = function() { + + var localctx = new OptschemaeltlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 46, PostgreSQLParser.RULE_optschemaeltlist); + try { + this.enterOuterAlt(localctx, 1); + this.state = 1884; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,16,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 1881; + this.schema_stmt(); + } + this.state = 1886; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,16,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Schema_stmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_schema_stmt; + return this; +} + +Schema_stmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Schema_stmtContext.prototype.constructor = Schema_stmtContext; + +Schema_stmtContext.prototype.createstmt = function() { + return this.getTypedRuleContext(CreatestmtContext,0); +}; + +Schema_stmtContext.prototype.indexstmt = function() { + return this.getTypedRuleContext(IndexstmtContext,0); +}; + +Schema_stmtContext.prototype.createseqstmt = function() { + return this.getTypedRuleContext(CreateseqstmtContext,0); +}; + +Schema_stmtContext.prototype.createtrigstmt = function() { + return this.getTypedRuleContext(CreatetrigstmtContext,0); +}; + +Schema_stmtContext.prototype.grantstmt = function() { + return this.getTypedRuleContext(GrantstmtContext,0); +}; + +Schema_stmtContext.prototype.viewstmt = function() { + return this.getTypedRuleContext(ViewstmtContext,0); +}; + +Schema_stmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSchema_stmt(this); + } +}; + +Schema_stmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSchema_stmt(this); + } +}; + +Schema_stmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSchema_stmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Schema_stmtContext = Schema_stmtContext; + +PostgreSQLParser.prototype.schema_stmt = function() { + + var localctx = new Schema_stmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 48, PostgreSQLParser.RULE_schema_stmt); + try { + this.state = 1893; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,17,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 1887; + this.createstmt(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 1888; + this.indexstmt(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 1889; + this.createseqstmt(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 1890; + this.createtrigstmt(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 1891; + this.grantstmt(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 1892; + this.viewstmt(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function VariablesetstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_variablesetstmt; + return this; +} + +VariablesetstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +VariablesetstmtContext.prototype.constructor = VariablesetstmtContext; + +VariablesetstmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +VariablesetstmtContext.prototype.set_rest = function() { + return this.getTypedRuleContext(Set_restContext,0); +}; + +VariablesetstmtContext.prototype.LOCAL = function() { + return this.getToken(PostgreSQLParser.LOCAL, 0); +}; + +VariablesetstmtContext.prototype.SESSION = function() { + return this.getToken(PostgreSQLParser.SESSION, 0); +}; + +VariablesetstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVariablesetstmt(this); + } +}; + +VariablesetstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVariablesetstmt(this); + } +}; + +VariablesetstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVariablesetstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.VariablesetstmtContext = VariablesetstmtContext; + +PostgreSQLParser.prototype.variablesetstmt = function() { + + var localctx = new VariablesetstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 50, PostgreSQLParser.RULE_variablesetstmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 1895; + this.match(PostgreSQLParser.SET); + this.state = 1897; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,18,this._ctx); + if(la_===1) { + this.state = 1896; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.LOCAL || _la===PostgreSQLParser.SESSION)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + + } + this.state = 1899; + this.set_rest(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Set_restContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_set_rest; + return this; +} + +Set_restContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Set_restContext.prototype.constructor = Set_restContext; + +Set_restContext.prototype.TRANSACTION = function() { + return this.getToken(PostgreSQLParser.TRANSACTION, 0); +}; + +Set_restContext.prototype.transaction_mode_list = function() { + return this.getTypedRuleContext(Transaction_mode_listContext,0); +}; + +Set_restContext.prototype.SESSION = function() { + return this.getToken(PostgreSQLParser.SESSION, 0); +}; + +Set_restContext.prototype.CHARACTERISTICS = function() { + return this.getToken(PostgreSQLParser.CHARACTERISTICS, 0); +}; + +Set_restContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Set_restContext.prototype.set_rest_more = function() { + return this.getTypedRuleContext(Set_rest_moreContext,0); +}; + +Set_restContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSet_rest(this); + } +}; + +Set_restContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSet_rest(this); + } +}; + +Set_restContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSet_rest(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Set_restContext = Set_restContext; + +PostgreSQLParser.prototype.set_rest = function() { + + var localctx = new Set_restContext(this, this._ctx, this.state); + this.enterRule(localctx, 52, PostgreSQLParser.RULE_set_rest); + try { + this.state = 1909; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,19,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 1901; + this.match(PostgreSQLParser.TRANSACTION); + this.state = 1902; + this.transaction_mode_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 1903; + this.match(PostgreSQLParser.SESSION); + this.state = 1904; + this.match(PostgreSQLParser.CHARACTERISTICS); + this.state = 1905; + this.match(PostgreSQLParser.AS); + this.state = 1906; + this.match(PostgreSQLParser.TRANSACTION); + this.state = 1907; + this.transaction_mode_list(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 1908; + this.set_rest_more(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Generic_setContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_generic_set; + return this; +} + +Generic_setContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Generic_setContext.prototype.constructor = Generic_setContext; + +Generic_setContext.prototype.var_name = function() { + return this.getTypedRuleContext(Var_nameContext,0); +}; + +Generic_setContext.prototype.var_list = function() { + return this.getTypedRuleContext(Var_listContext,0); +}; + +Generic_setContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +Generic_setContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +Generic_setContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGeneric_set(this); + } +}; + +Generic_setContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGeneric_set(this); + } +}; + +Generic_setContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGeneric_set(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Generic_setContext = Generic_setContext; + +PostgreSQLParser.prototype.generic_set = function() { + + var localctx = new Generic_setContext(this, this._ctx, this.state); + this.enterRule(localctx, 54, PostgreSQLParser.RULE_generic_set); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 1911; + this.var_name(); + this.state = 1912; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.EQUAL || _la===PostgreSQLParser.TO)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 1913; + this.var_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Set_rest_moreContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_set_rest_more; + return this; +} + +Set_rest_moreContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Set_rest_moreContext.prototype.constructor = Set_rest_moreContext; + +Set_rest_moreContext.prototype.generic_set = function() { + return this.getTypedRuleContext(Generic_setContext,0); +}; + +Set_rest_moreContext.prototype.var_name = function() { + return this.getTypedRuleContext(Var_nameContext,0); +}; + +Set_rest_moreContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Set_rest_moreContext.prototype.CURRENT_P = function() { + return this.getToken(PostgreSQLParser.CURRENT_P, 0); +}; + +Set_rest_moreContext.prototype.TIME = function() { + return this.getToken(PostgreSQLParser.TIME, 0); +}; + +Set_rest_moreContext.prototype.ZONE = function() { + return this.getToken(PostgreSQLParser.ZONE, 0); +}; + +Set_rest_moreContext.prototype.zone_value = function() { + return this.getTypedRuleContext(Zone_valueContext,0); +}; + +Set_rest_moreContext.prototype.CATALOG = function() { + return this.getToken(PostgreSQLParser.CATALOG, 0); +}; + +Set_rest_moreContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Set_rest_moreContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +Set_rest_moreContext.prototype.NAMES = function() { + return this.getToken(PostgreSQLParser.NAMES, 0); +}; + +Set_rest_moreContext.prototype.opt_encoding = function() { + return this.getTypedRuleContext(Opt_encodingContext,0); +}; + +Set_rest_moreContext.prototype.ROLE = function() { + return this.getToken(PostgreSQLParser.ROLE, 0); +}; + +Set_rest_moreContext.prototype.nonreservedword_or_sconst = function() { + return this.getTypedRuleContext(Nonreservedword_or_sconstContext,0); +}; + +Set_rest_moreContext.prototype.SESSION = function() { + return this.getToken(PostgreSQLParser.SESSION, 0); +}; + +Set_rest_moreContext.prototype.AUTHORIZATION = function() { + return this.getToken(PostgreSQLParser.AUTHORIZATION, 0); +}; + +Set_rest_moreContext.prototype.XML_P = function() { + return this.getToken(PostgreSQLParser.XML_P, 0); +}; + +Set_rest_moreContext.prototype.OPTION = function() { + return this.getToken(PostgreSQLParser.OPTION, 0); +}; + +Set_rest_moreContext.prototype.document_or_content = function() { + return this.getTypedRuleContext(Document_or_contentContext,0); +}; + +Set_rest_moreContext.prototype.TRANSACTION = function() { + return this.getToken(PostgreSQLParser.TRANSACTION, 0); +}; + +Set_rest_moreContext.prototype.SNAPSHOT = function() { + return this.getToken(PostgreSQLParser.SNAPSHOT, 0); +}; + +Set_rest_moreContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSet_rest_more(this); + } +}; + +Set_rest_moreContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSet_rest_more(this); + } +}; + +Set_rest_moreContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSet_rest_more(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Set_rest_moreContext = Set_rest_moreContext; + +PostgreSQLParser.prototype.set_rest_more = function() { + + var localctx = new Set_rest_moreContext(this, this._ctx, this.state); + this.enterRule(localctx, 56, PostgreSQLParser.RULE_set_rest_more); + try { + this.state = 1940; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,20,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 1915; + this.generic_set(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 1916; + this.var_name(); + this.state = 1917; + this.match(PostgreSQLParser.FROM); + this.state = 1918; + this.match(PostgreSQLParser.CURRENT_P); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 1920; + this.match(PostgreSQLParser.TIME); + this.state = 1921; + this.match(PostgreSQLParser.ZONE); + this.state = 1922; + this.zone_value(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 1923; + this.match(PostgreSQLParser.CATALOG); + this.state = 1924; + this.sconst(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 1925; + this.match(PostgreSQLParser.SCHEMA); + this.state = 1926; + this.sconst(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 1927; + this.match(PostgreSQLParser.NAMES); + this.state = 1928; + this.opt_encoding(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 1929; + this.match(PostgreSQLParser.ROLE); + this.state = 1930; + this.nonreservedword_or_sconst(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 1931; + this.match(PostgreSQLParser.SESSION); + this.state = 1932; + this.match(PostgreSQLParser.AUTHORIZATION); + this.state = 1933; + this.nonreservedword_or_sconst(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 1934; + this.match(PostgreSQLParser.XML_P); + this.state = 1935; + this.match(PostgreSQLParser.OPTION); + this.state = 1936; + this.document_or_content(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 1937; + this.match(PostgreSQLParser.TRANSACTION); + this.state = 1938; + this.match(PostgreSQLParser.SNAPSHOT); + this.state = 1939; + this.sconst(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Var_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_var_name; + return this; +} + +Var_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Var_nameContext.prototype.constructor = Var_nameContext; + +Var_nameContext.prototype.colid = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(ColidContext); + } else { + return this.getTypedRuleContext(ColidContext,i); + } +}; + +Var_nameContext.prototype.DOT = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.DOT); + } else { + return this.getToken(PostgreSQLParser.DOT, i); + } +}; + + +Var_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVar_name(this); + } +}; + +Var_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVar_name(this); + } +}; + +Var_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVar_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Var_nameContext = Var_nameContext; + +PostgreSQLParser.prototype.var_name = function() { + + var localctx = new Var_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 58, PostgreSQLParser.RULE_var_name); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 1942; + this.colid(); + this.state = 1947; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.DOT) { + this.state = 1943; + this.match(PostgreSQLParser.DOT); + this.state = 1944; + this.colid(); + this.state = 1949; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Var_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_var_list; + return this; +} + +Var_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Var_listContext.prototype.constructor = Var_listContext; + +Var_listContext.prototype.var_value = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Var_valueContext); + } else { + return this.getTypedRuleContext(Var_valueContext,i); + } +}; + +Var_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Var_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVar_list(this); + } +}; + +Var_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVar_list(this); + } +}; + +Var_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVar_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Var_listContext = Var_listContext; + +PostgreSQLParser.prototype.var_list = function() { + + var localctx = new Var_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 60, PostgreSQLParser.RULE_var_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 1950; + this.var_value(); + this.state = 1955; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 1951; + this.match(PostgreSQLParser.COMMA); + this.state = 1952; + this.var_value(); + this.state = 1957; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Var_valueContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_var_value; + return this; +} + +Var_valueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Var_valueContext.prototype.constructor = Var_valueContext; + +Var_valueContext.prototype.opt_boolean_or_string = function() { + return this.getTypedRuleContext(Opt_boolean_or_stringContext,0); +}; + +Var_valueContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +Var_valueContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVar_value(this); + } +}; + +Var_valueContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVar_value(this); + } +}; + +Var_valueContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVar_value(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Var_valueContext = Var_valueContext; + +PostgreSQLParser.prototype.var_value = function() { + + var localctx = new Var_valueContext(this, this._ctx, this.state); + this.enterRule(localctx, 62, PostgreSQLParser.RULE_var_value); + try { + this.state = 1960; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.ON: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 1958; + this.opt_boolean_or_string(); + break; + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + this.enterOuterAlt(localctx, 2); + this.state = 1959; + this.numericonly(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Iso_levelContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_iso_level; + return this; +} + +Iso_levelContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Iso_levelContext.prototype.constructor = Iso_levelContext; + +Iso_levelContext.prototype.READ = function() { + return this.getToken(PostgreSQLParser.READ, 0); +}; + +Iso_levelContext.prototype.UNCOMMITTED = function() { + return this.getToken(PostgreSQLParser.UNCOMMITTED, 0); +}; + +Iso_levelContext.prototype.COMMITTED = function() { + return this.getToken(PostgreSQLParser.COMMITTED, 0); +}; + +Iso_levelContext.prototype.REPEATABLE = function() { + return this.getToken(PostgreSQLParser.REPEATABLE, 0); +}; + +Iso_levelContext.prototype.SERIALIZABLE = function() { + return this.getToken(PostgreSQLParser.SERIALIZABLE, 0); +}; + +Iso_levelContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIso_level(this); + } +}; + +Iso_levelContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIso_level(this); + } +}; + +Iso_levelContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIso_level(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Iso_levelContext = Iso_levelContext; + +PostgreSQLParser.prototype.iso_level = function() { + + var localctx = new Iso_levelContext(this, this._ctx, this.state); + this.enterRule(localctx, 64, PostgreSQLParser.RULE_iso_level); + var _la = 0; // Token type + try { + this.state = 1967; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.READ: + this.enterOuterAlt(localctx, 1); + this.state = 1962; + this.match(PostgreSQLParser.READ); + this.state = 1963; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.COMMITTED || _la===PostgreSQLParser.UNCOMMITTED)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + case PostgreSQLParser.REPEATABLE: + this.enterOuterAlt(localctx, 2); + this.state = 1964; + this.match(PostgreSQLParser.REPEATABLE); + this.state = 1965; + this.match(PostgreSQLParser.READ); + break; + case PostgreSQLParser.SERIALIZABLE: + this.enterOuterAlt(localctx, 3); + this.state = 1966; + this.match(PostgreSQLParser.SERIALIZABLE); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_boolean_or_stringContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_boolean_or_string; + return this; +} + +Opt_boolean_or_stringContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_boolean_or_stringContext.prototype.constructor = Opt_boolean_or_stringContext; + +Opt_boolean_or_stringContext.prototype.TRUE_P = function() { + return this.getToken(PostgreSQLParser.TRUE_P, 0); +}; + +Opt_boolean_or_stringContext.prototype.FALSE_P = function() { + return this.getToken(PostgreSQLParser.FALSE_P, 0); +}; + +Opt_boolean_or_stringContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +Opt_boolean_or_stringContext.prototype.nonreservedword_or_sconst = function() { + return this.getTypedRuleContext(Nonreservedword_or_sconstContext,0); +}; + +Opt_boolean_or_stringContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_boolean_or_string(this); + } +}; + +Opt_boolean_or_stringContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_boolean_or_string(this); + } +}; + +Opt_boolean_or_stringContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_boolean_or_string(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_boolean_or_stringContext = Opt_boolean_or_stringContext; + +PostgreSQLParser.prototype.opt_boolean_or_string = function() { + + var localctx = new Opt_boolean_or_stringContext(this, this._ctx, this.state); + this.enterRule(localctx, 66, PostgreSQLParser.RULE_opt_boolean_or_string); + try { + this.state = 1973; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.TRUE_P: + this.enterOuterAlt(localctx, 1); + this.state = 1969; + this.match(PostgreSQLParser.TRUE_P); + break; + case PostgreSQLParser.FALSE_P: + this.enterOuterAlt(localctx, 2); + this.state = 1970; + this.match(PostgreSQLParser.FALSE_P); + break; + case PostgreSQLParser.ON: + this.enterOuterAlt(localctx, 3); + this.state = 1971; + this.match(PostgreSQLParser.ON); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 4); + this.state = 1972; + this.nonreservedword_or_sconst(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Zone_valueContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_zone_value; + return this; +} + +Zone_valueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Zone_valueContext.prototype.constructor = Zone_valueContext; + +Zone_valueContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Zone_valueContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +Zone_valueContext.prototype.constinterval = function() { + return this.getTypedRuleContext(ConstintervalContext,0); +}; + +Zone_valueContext.prototype.opt_interval = function() { + return this.getTypedRuleContext(Opt_intervalContext,0); +}; + +Zone_valueContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Zone_valueContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +Zone_valueContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Zone_valueContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +Zone_valueContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Zone_valueContext.prototype.LOCAL = function() { + return this.getToken(PostgreSQLParser.LOCAL, 0); +}; + +Zone_valueContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterZone_value(this); + } +}; + +Zone_valueContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitZone_value(this); + } +}; + +Zone_valueContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitZone_value(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Zone_valueContext = Zone_valueContext; + +PostgreSQLParser.prototype.zone_value = function() { + + var localctx = new Zone_valueContext(this, this._ctx, this.state); + this.enterRule(localctx, 68, PostgreSQLParser.RULE_zone_value); + try { + this.state = 1990; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,26,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 1975; + this.sconst(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 1976; + this.identifier(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 1977; + this.constinterval(); + this.state = 1978; + this.sconst(); + this.state = 1979; + this.opt_interval(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 1981; + this.constinterval(); + this.state = 1982; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 1983; + this.iconst(); + this.state = 1984; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 1985; + this.sconst(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 1987; + this.numericonly(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 1988; + this.match(PostgreSQLParser.DEFAULT); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 1989; + this.match(PostgreSQLParser.LOCAL); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_encodingContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_encoding; + return this; +} + +Opt_encodingContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_encodingContext.prototype.constructor = Opt_encodingContext; + +Opt_encodingContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Opt_encodingContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Opt_encodingContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_encoding(this); + } +}; + +Opt_encodingContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_encoding(this); + } +}; + +Opt_encodingContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_encoding(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_encodingContext = Opt_encodingContext; + +PostgreSQLParser.prototype.opt_encoding = function() { + + var localctx = new Opt_encodingContext(this, this._ctx, this.state); + this.enterRule(localctx, 70, PostgreSQLParser.RULE_opt_encoding); + try { + this.state = 1995; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 1992; + this.sconst(); + break; + case PostgreSQLParser.DEFAULT: + this.enterOuterAlt(localctx, 2); + this.state = 1993; + this.match(PostgreSQLParser.DEFAULT); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AS: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.NOT: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.START: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Nonreservedword_or_sconstContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_nonreservedword_or_sconst; + return this; +} + +Nonreservedword_or_sconstContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Nonreservedword_or_sconstContext.prototype.constructor = Nonreservedword_or_sconstContext; + +Nonreservedword_or_sconstContext.prototype.nonreservedword = function() { + return this.getTypedRuleContext(NonreservedwordContext,0); +}; + +Nonreservedword_or_sconstContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Nonreservedword_or_sconstContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterNonreservedword_or_sconst(this); + } +}; + +Nonreservedword_or_sconstContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitNonreservedword_or_sconst(this); + } +}; + +Nonreservedword_or_sconstContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitNonreservedword_or_sconst(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Nonreservedword_or_sconstContext = Nonreservedword_or_sconstContext; + +PostgreSQLParser.prototype.nonreservedword_or_sconst = function() { + + var localctx = new Nonreservedword_or_sconstContext(this, this._ctx, this.state); + this.enterRule(localctx, 72, PostgreSQLParser.RULE_nonreservedword_or_sconst); + try { + this.state = 1999; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 1997; + this.nonreservedword(); + break; + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 2); + this.state = 1998; + this.sconst(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function VariableresetstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_variableresetstmt; + return this; +} + +VariableresetstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +VariableresetstmtContext.prototype.constructor = VariableresetstmtContext; + +VariableresetstmtContext.prototype.RESET = function() { + return this.getToken(PostgreSQLParser.RESET, 0); +}; + +VariableresetstmtContext.prototype.reset_rest = function() { + return this.getTypedRuleContext(Reset_restContext,0); +}; + +VariableresetstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVariableresetstmt(this); + } +}; + +VariableresetstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVariableresetstmt(this); + } +}; + +VariableresetstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVariableresetstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.VariableresetstmtContext = VariableresetstmtContext; + +PostgreSQLParser.prototype.variableresetstmt = function() { + + var localctx = new VariableresetstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 74, PostgreSQLParser.RULE_variableresetstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2001; + this.match(PostgreSQLParser.RESET); + this.state = 2002; + this.reset_rest(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Reset_restContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reset_rest; + return this; +} + +Reset_restContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Reset_restContext.prototype.constructor = Reset_restContext; + +Reset_restContext.prototype.generic_reset = function() { + return this.getTypedRuleContext(Generic_resetContext,0); +}; + +Reset_restContext.prototype.TIME = function() { + return this.getToken(PostgreSQLParser.TIME, 0); +}; + +Reset_restContext.prototype.ZONE = function() { + return this.getToken(PostgreSQLParser.ZONE, 0); +}; + +Reset_restContext.prototype.TRANSACTION = function() { + return this.getToken(PostgreSQLParser.TRANSACTION, 0); +}; + +Reset_restContext.prototype.ISOLATION = function() { + return this.getToken(PostgreSQLParser.ISOLATION, 0); +}; + +Reset_restContext.prototype.LEVEL = function() { + return this.getToken(PostgreSQLParser.LEVEL, 0); +}; + +Reset_restContext.prototype.SESSION = function() { + return this.getToken(PostgreSQLParser.SESSION, 0); +}; + +Reset_restContext.prototype.AUTHORIZATION = function() { + return this.getToken(PostgreSQLParser.AUTHORIZATION, 0); +}; + +Reset_restContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReset_rest(this); + } +}; + +Reset_restContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReset_rest(this); + } +}; + +Reset_restContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReset_rest(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Reset_restContext = Reset_restContext; + +PostgreSQLParser.prototype.reset_rest = function() { + + var localctx = new Reset_restContext(this, this._ctx, this.state); + this.enterRule(localctx, 76, PostgreSQLParser.RULE_reset_rest); + try { + this.state = 2012; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,29,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2004; + this.generic_reset(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 2005; + this.match(PostgreSQLParser.TIME); + this.state = 2006; + this.match(PostgreSQLParser.ZONE); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 2007; + this.match(PostgreSQLParser.TRANSACTION); + this.state = 2008; + this.match(PostgreSQLParser.ISOLATION); + this.state = 2009; + this.match(PostgreSQLParser.LEVEL); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 2010; + this.match(PostgreSQLParser.SESSION); + this.state = 2011; + this.match(PostgreSQLParser.AUTHORIZATION); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Generic_resetContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_generic_reset; + return this; +} + +Generic_resetContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Generic_resetContext.prototype.constructor = Generic_resetContext; + +Generic_resetContext.prototype.var_name = function() { + return this.getTypedRuleContext(Var_nameContext,0); +}; + +Generic_resetContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Generic_resetContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGeneric_reset(this); + } +}; + +Generic_resetContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGeneric_reset(this); + } +}; + +Generic_resetContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGeneric_reset(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Generic_resetContext = Generic_resetContext; + +PostgreSQLParser.prototype.generic_reset = function() { + + var localctx = new Generic_resetContext(this, this._ctx, this.state); + this.enterRule(localctx, 78, PostgreSQLParser.RULE_generic_reset); + try { + this.state = 2016; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 2014; + this.var_name(); + break; + case PostgreSQLParser.ALL: + this.enterOuterAlt(localctx, 2); + this.state = 2015; + this.match(PostgreSQLParser.ALL); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function SetresetclauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_setresetclause; + return this; +} + +SetresetclauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +SetresetclauseContext.prototype.constructor = SetresetclauseContext; + +SetresetclauseContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +SetresetclauseContext.prototype.set_rest = function() { + return this.getTypedRuleContext(Set_restContext,0); +}; + +SetresetclauseContext.prototype.variableresetstmt = function() { + return this.getTypedRuleContext(VariableresetstmtContext,0); +}; + +SetresetclauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSetresetclause(this); + } +}; + +SetresetclauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSetresetclause(this); + } +}; + +SetresetclauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSetresetclause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.SetresetclauseContext = SetresetclauseContext; + +PostgreSQLParser.prototype.setresetclause = function() { + + var localctx = new SetresetclauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 80, PostgreSQLParser.RULE_setresetclause); + try { + this.state = 2021; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SET: + this.enterOuterAlt(localctx, 1); + this.state = 2018; + this.match(PostgreSQLParser.SET); + this.state = 2019; + this.set_rest(); + break; + case PostgreSQLParser.RESET: + this.enterOuterAlt(localctx, 2); + this.state = 2020; + this.variableresetstmt(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function FunctionsetresetclauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_functionsetresetclause; + return this; +} + +FunctionsetresetclauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +FunctionsetresetclauseContext.prototype.constructor = FunctionsetresetclauseContext; + +FunctionsetresetclauseContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +FunctionsetresetclauseContext.prototype.set_rest_more = function() { + return this.getTypedRuleContext(Set_rest_moreContext,0); +}; + +FunctionsetresetclauseContext.prototype.variableresetstmt = function() { + return this.getTypedRuleContext(VariableresetstmtContext,0); +}; + +FunctionsetresetclauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunctionsetresetclause(this); + } +}; + +FunctionsetresetclauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunctionsetresetclause(this); + } +}; + +FunctionsetresetclauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunctionsetresetclause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.FunctionsetresetclauseContext = FunctionsetresetclauseContext; + +PostgreSQLParser.prototype.functionsetresetclause = function() { + + var localctx = new FunctionsetresetclauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 82, PostgreSQLParser.RULE_functionsetresetclause); + try { + this.state = 2026; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SET: + this.enterOuterAlt(localctx, 1); + this.state = 2023; + this.match(PostgreSQLParser.SET); + this.state = 2024; + this.set_rest_more(); + break; + case PostgreSQLParser.RESET: + this.enterOuterAlt(localctx, 2); + this.state = 2025; + this.variableresetstmt(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function VariableshowstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_variableshowstmt; + return this; +} + +VariableshowstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +VariableshowstmtContext.prototype.constructor = VariableshowstmtContext; + +VariableshowstmtContext.prototype.SHOW = function() { + return this.getToken(PostgreSQLParser.SHOW, 0); +}; + +VariableshowstmtContext.prototype.var_name = function() { + return this.getTypedRuleContext(Var_nameContext,0); +}; + +VariableshowstmtContext.prototype.TIME = function() { + return this.getToken(PostgreSQLParser.TIME, 0); +}; + +VariableshowstmtContext.prototype.ZONE = function() { + return this.getToken(PostgreSQLParser.ZONE, 0); +}; + +VariableshowstmtContext.prototype.TRANSACTION = function() { + return this.getToken(PostgreSQLParser.TRANSACTION, 0); +}; + +VariableshowstmtContext.prototype.ISOLATION = function() { + return this.getToken(PostgreSQLParser.ISOLATION, 0); +}; + +VariableshowstmtContext.prototype.LEVEL = function() { + return this.getToken(PostgreSQLParser.LEVEL, 0); +}; + +VariableshowstmtContext.prototype.SESSION = function() { + return this.getToken(PostgreSQLParser.SESSION, 0); +}; + +VariableshowstmtContext.prototype.AUTHORIZATION = function() { + return this.getToken(PostgreSQLParser.AUTHORIZATION, 0); +}; + +VariableshowstmtContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +VariableshowstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVariableshowstmt(this); + } +}; + +VariableshowstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVariableshowstmt(this); + } +}; + +VariableshowstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVariableshowstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.VariableshowstmtContext = VariableshowstmtContext; + +PostgreSQLParser.prototype.variableshowstmt = function() { + + var localctx = new VariableshowstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 84, PostgreSQLParser.RULE_variableshowstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2028; + this.match(PostgreSQLParser.SHOW); + this.state = 2038; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,33,this._ctx); + switch(la_) { + case 1: + this.state = 2029; + this.var_name(); + break; + + case 2: + this.state = 2030; + this.match(PostgreSQLParser.TIME); + this.state = 2031; + this.match(PostgreSQLParser.ZONE); + break; + + case 3: + this.state = 2032; + this.match(PostgreSQLParser.TRANSACTION); + this.state = 2033; + this.match(PostgreSQLParser.ISOLATION); + this.state = 2034; + this.match(PostgreSQLParser.LEVEL); + break; + + case 4: + this.state = 2035; + this.match(PostgreSQLParser.SESSION); + this.state = 2036; + this.match(PostgreSQLParser.AUTHORIZATION); + break; + + case 5: + this.state = 2037; + this.match(PostgreSQLParser.ALL); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ConstraintssetstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constraintssetstmt; + return this; +} + +ConstraintssetstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ConstraintssetstmtContext.prototype.constructor = ConstraintssetstmtContext; + +ConstraintssetstmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +ConstraintssetstmtContext.prototype.CONSTRAINTS = function() { + return this.getToken(PostgreSQLParser.CONSTRAINTS, 0); +}; + +ConstraintssetstmtContext.prototype.constraints_set_list = function() { + return this.getTypedRuleContext(Constraints_set_listContext,0); +}; + +ConstraintssetstmtContext.prototype.constraints_set_mode = function() { + return this.getTypedRuleContext(Constraints_set_modeContext,0); +}; + +ConstraintssetstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstraintssetstmt(this); + } +}; + +ConstraintssetstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstraintssetstmt(this); + } +}; + +ConstraintssetstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstraintssetstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ConstraintssetstmtContext = ConstraintssetstmtContext; + +PostgreSQLParser.prototype.constraintssetstmt = function() { + + var localctx = new ConstraintssetstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 86, PostgreSQLParser.RULE_constraintssetstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2040; + this.match(PostgreSQLParser.SET); + this.state = 2041; + this.match(PostgreSQLParser.CONSTRAINTS); + this.state = 2042; + this.constraints_set_list(); + this.state = 2043; + this.constraints_set_mode(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Constraints_set_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constraints_set_list; + return this; +} + +Constraints_set_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Constraints_set_listContext.prototype.constructor = Constraints_set_listContext; + +Constraints_set_listContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Constraints_set_listContext.prototype.qualified_name_list = function() { + return this.getTypedRuleContext(Qualified_name_listContext,0); +}; + +Constraints_set_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstraints_set_list(this); + } +}; + +Constraints_set_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstraints_set_list(this); + } +}; + +Constraints_set_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstraints_set_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Constraints_set_listContext = Constraints_set_listContext; + +PostgreSQLParser.prototype.constraints_set_list = function() { + + var localctx = new Constraints_set_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 88, PostgreSQLParser.RULE_constraints_set_list); + try { + this.state = 2047; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ALL: + this.enterOuterAlt(localctx, 1); + this.state = 2045; + this.match(PostgreSQLParser.ALL); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 2); + this.state = 2046; + this.qualified_name_list(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Constraints_set_modeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constraints_set_mode; + return this; +} + +Constraints_set_modeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Constraints_set_modeContext.prototype.constructor = Constraints_set_modeContext; + +Constraints_set_modeContext.prototype.DEFERRED = function() { + return this.getToken(PostgreSQLParser.DEFERRED, 0); +}; + +Constraints_set_modeContext.prototype.IMMEDIATE = function() { + return this.getToken(PostgreSQLParser.IMMEDIATE, 0); +}; + +Constraints_set_modeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstraints_set_mode(this); + } +}; + +Constraints_set_modeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstraints_set_mode(this); + } +}; + +Constraints_set_modeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstraints_set_mode(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Constraints_set_modeContext = Constraints_set_modeContext; + +PostgreSQLParser.prototype.constraints_set_mode = function() { + + var localctx = new Constraints_set_modeContext(this, this._ctx, this.state); + this.enterRule(localctx, 90, PostgreSQLParser.RULE_constraints_set_mode); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2049; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.DEFERRED || _la===PostgreSQLParser.IMMEDIATE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CheckpointstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_checkpointstmt; + return this; +} + +CheckpointstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CheckpointstmtContext.prototype.constructor = CheckpointstmtContext; + +CheckpointstmtContext.prototype.CHECKPOINT = function() { + return this.getToken(PostgreSQLParser.CHECKPOINT, 0); +}; + +CheckpointstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCheckpointstmt(this); + } +}; + +CheckpointstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCheckpointstmt(this); + } +}; + +CheckpointstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCheckpointstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CheckpointstmtContext = CheckpointstmtContext; + +PostgreSQLParser.prototype.checkpointstmt = function() { + + var localctx = new CheckpointstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 92, PostgreSQLParser.RULE_checkpointstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2051; + this.match(PostgreSQLParser.CHECKPOINT); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DiscardstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_discardstmt; + return this; +} + +DiscardstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DiscardstmtContext.prototype.constructor = DiscardstmtContext; + +DiscardstmtContext.prototype.DISCARD = function() { + return this.getToken(PostgreSQLParser.DISCARD, 0); +}; + +DiscardstmtContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +DiscardstmtContext.prototype.TEMP = function() { + return this.getToken(PostgreSQLParser.TEMP, 0); +}; + +DiscardstmtContext.prototype.TEMPORARY = function() { + return this.getToken(PostgreSQLParser.TEMPORARY, 0); +}; + +DiscardstmtContext.prototype.PLANS = function() { + return this.getToken(PostgreSQLParser.PLANS, 0); +}; + +DiscardstmtContext.prototype.SEQUENCES = function() { + return this.getToken(PostgreSQLParser.SEQUENCES, 0); +}; + +DiscardstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDiscardstmt(this); + } +}; + +DiscardstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDiscardstmt(this); + } +}; + +DiscardstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDiscardstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DiscardstmtContext = DiscardstmtContext; + +PostgreSQLParser.prototype.discardstmt = function() { + + var localctx = new DiscardstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 94, PostgreSQLParser.RULE_discardstmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2053; + this.match(PostgreSQLParser.DISCARD); + this.state = 2054; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.ALL || _la===PostgreSQLParser.PLANS || ((((_la - 320)) & ~0x1f) == 0 && ((1 << (_la - 320)) & ((1 << (PostgreSQLParser.SEQUENCES - 320)) | (1 << (PostgreSQLParser.TEMP - 320)) | (1 << (PostgreSQLParser.TEMPORARY - 320)))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltertablestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altertablestmt; + return this; +} + +AltertablestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltertablestmtContext.prototype.constructor = AltertablestmtContext; + +AltertablestmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AltertablestmtContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +AltertablestmtContext.prototype.relation_expr = function() { + return this.getTypedRuleContext(Relation_exprContext,0); +}; + +AltertablestmtContext.prototype.alter_table_cmds = function() { + return this.getTypedRuleContext(Alter_table_cmdsContext,0); +}; + +AltertablestmtContext.prototype.partition_cmd = function() { + return this.getTypedRuleContext(Partition_cmdContext,0); +}; + +AltertablestmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +AltertablestmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +AltertablestmtContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +AltertablestmtContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +AltertablestmtContext.prototype.TABLESPACE = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.TABLESPACE); + } else { + return this.getToken(PostgreSQLParser.TABLESPACE, i); + } +}; + + +AltertablestmtContext.prototype.name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(NameContext); + } else { + return this.getTypedRuleContext(NameContext,i); + } +}; + +AltertablestmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AltertablestmtContext.prototype.opt_nowait = function() { + return this.getTypedRuleContext(Opt_nowaitContext,0); +}; + +AltertablestmtContext.prototype.OWNED = function() { + return this.getToken(PostgreSQLParser.OWNED, 0); +}; + +AltertablestmtContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +AltertablestmtContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +AltertablestmtContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +AltertablestmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +AltertablestmtContext.prototype.index_partition_cmd = function() { + return this.getTypedRuleContext(Index_partition_cmdContext,0); +}; + +AltertablestmtContext.prototype.SEQUENCE = function() { + return this.getToken(PostgreSQLParser.SEQUENCE, 0); +}; + +AltertablestmtContext.prototype.VIEW = function() { + return this.getToken(PostgreSQLParser.VIEW, 0); +}; + +AltertablestmtContext.prototype.MATERIALIZED = function() { + return this.getToken(PostgreSQLParser.MATERIALIZED, 0); +}; + +AltertablestmtContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +AltertablestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltertablestmt(this); + } +}; + +AltertablestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltertablestmt(this); + } +}; + +AltertablestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltertablestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltertablestmtContext = AltertablestmtContext; + +PostgreSQLParser.prototype.altertablestmt = function() { + + var localctx = new AltertablestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 96, PostgreSQLParser.RULE_altertablestmt); + var _la = 0; // Token type + try { + this.state = 2165; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,46,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2056; + this.match(PostgreSQLParser.ALTER); + this.state = 2057; + this.match(PostgreSQLParser.TABLE); + this.state = 2060; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,35,this._ctx); + if(la_===1) { + this.state = 2058; + this.match(PostgreSQLParser.IF_P); + this.state = 2059; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 2062; + this.relation_expr(); + this.state = 2065; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NOT: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.NO: + case PostgreSQLParser.OF: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.SET: + case PostgreSQLParser.VALIDATE: + this.state = 2063; + this.alter_table_cmds(); + break; + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + this.state = 2064; + this.partition_cmd(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 2067; + this.match(PostgreSQLParser.ALTER); + this.state = 2068; + this.match(PostgreSQLParser.TABLE); + this.state = 2069; + this.match(PostgreSQLParser.ALL); + this.state = 2070; + this.match(PostgreSQLParser.IN_P); + this.state = 2071; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 2072; + this.name(); + this.state = 2076; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OWNED) { + this.state = 2073; + this.match(PostgreSQLParser.OWNED); + this.state = 2074; + this.match(PostgreSQLParser.BY); + this.state = 2075; + this.role_list(); + } + + this.state = 2078; + this.match(PostgreSQLParser.SET); + this.state = 2079; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 2080; + this.name(); + this.state = 2081; + this.opt_nowait(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 2083; + this.match(PostgreSQLParser.ALTER); + this.state = 2084; + this.match(PostgreSQLParser.INDEX); + this.state = 2087; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,38,this._ctx); + if(la_===1) { + this.state = 2085; + this.match(PostgreSQLParser.IF_P); + this.state = 2086; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 2089; + this.qualified_name(); + this.state = 2092; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NOT: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.NO: + case PostgreSQLParser.OF: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.SET: + case PostgreSQLParser.VALIDATE: + this.state = 2090; + this.alter_table_cmds(); + break; + case PostgreSQLParser.ATTACH: + this.state = 2091; + this.index_partition_cmd(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 2094; + this.match(PostgreSQLParser.ALTER); + this.state = 2095; + this.match(PostgreSQLParser.INDEX); + this.state = 2096; + this.match(PostgreSQLParser.ALL); + this.state = 2097; + this.match(PostgreSQLParser.IN_P); + this.state = 2098; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 2099; + this.name(); + this.state = 2103; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OWNED) { + this.state = 2100; + this.match(PostgreSQLParser.OWNED); + this.state = 2101; + this.match(PostgreSQLParser.BY); + this.state = 2102; + this.role_list(); + } + + this.state = 2105; + this.match(PostgreSQLParser.SET); + this.state = 2106; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 2107; + this.name(); + this.state = 2108; + this.opt_nowait(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 2110; + this.match(PostgreSQLParser.ALTER); + this.state = 2111; + this.match(PostgreSQLParser.SEQUENCE); + this.state = 2114; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,41,this._ctx); + if(la_===1) { + this.state = 2112; + this.match(PostgreSQLParser.IF_P); + this.state = 2113; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 2116; + this.qualified_name(); + this.state = 2117; + this.alter_table_cmds(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 2119; + this.match(PostgreSQLParser.ALTER); + this.state = 2120; + this.match(PostgreSQLParser.VIEW); + this.state = 2123; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,42,this._ctx); + if(la_===1) { + this.state = 2121; + this.match(PostgreSQLParser.IF_P); + this.state = 2122; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 2125; + this.qualified_name(); + this.state = 2126; + this.alter_table_cmds(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 2128; + this.match(PostgreSQLParser.ALTER); + this.state = 2129; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 2130; + this.match(PostgreSQLParser.VIEW); + this.state = 2133; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,43,this._ctx); + if(la_===1) { + this.state = 2131; + this.match(PostgreSQLParser.IF_P); + this.state = 2132; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 2135; + this.qualified_name(); + this.state = 2136; + this.alter_table_cmds(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 2138; + this.match(PostgreSQLParser.ALTER); + this.state = 2139; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 2140; + this.match(PostgreSQLParser.VIEW); + this.state = 2141; + this.match(PostgreSQLParser.ALL); + this.state = 2142; + this.match(PostgreSQLParser.IN_P); + this.state = 2143; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 2144; + this.name(); + this.state = 2148; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OWNED) { + this.state = 2145; + this.match(PostgreSQLParser.OWNED); + this.state = 2146; + this.match(PostgreSQLParser.BY); + this.state = 2147; + this.role_list(); + } + + this.state = 2150; + this.match(PostgreSQLParser.SET); + this.state = 2151; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 2152; + this.name(); + this.state = 2153; + this.opt_nowait(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 2155; + this.match(PostgreSQLParser.ALTER); + this.state = 2156; + this.match(PostgreSQLParser.FOREIGN); + this.state = 2157; + this.match(PostgreSQLParser.TABLE); + this.state = 2160; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,45,this._ctx); + if(la_===1) { + this.state = 2158; + this.match(PostgreSQLParser.IF_P); + this.state = 2159; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 2162; + this.relation_expr(); + this.state = 2163; + this.alter_table_cmds(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_table_cmdsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_table_cmds; + return this; +} + +Alter_table_cmdsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_table_cmdsContext.prototype.constructor = Alter_table_cmdsContext; + +Alter_table_cmdsContext.prototype.alter_table_cmd = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Alter_table_cmdContext); + } else { + return this.getTypedRuleContext(Alter_table_cmdContext,i); + } +}; + +Alter_table_cmdsContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Alter_table_cmdsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_table_cmds(this); + } +}; + +Alter_table_cmdsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_table_cmds(this); + } +}; + +Alter_table_cmdsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_table_cmds(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_table_cmdsContext = Alter_table_cmdsContext; + +PostgreSQLParser.prototype.alter_table_cmds = function() { + + var localctx = new Alter_table_cmdsContext(this, this._ctx, this.state); + this.enterRule(localctx, 98, PostgreSQLParser.RULE_alter_table_cmds); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2167; + this.alter_table_cmd(); + this.state = 2172; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 2168; + this.match(PostgreSQLParser.COMMA); + this.state = 2169; + this.alter_table_cmd(); + this.state = 2174; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Partition_cmdContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_partition_cmd; + return this; +} + +Partition_cmdContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Partition_cmdContext.prototype.constructor = Partition_cmdContext; + +Partition_cmdContext.prototype.ATTACH = function() { + return this.getToken(PostgreSQLParser.ATTACH, 0); +}; + +Partition_cmdContext.prototype.PARTITION = function() { + return this.getToken(PostgreSQLParser.PARTITION, 0); +}; + +Partition_cmdContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +Partition_cmdContext.prototype.partitionboundspec = function() { + return this.getTypedRuleContext(PartitionboundspecContext,0); +}; + +Partition_cmdContext.prototype.DETACH = function() { + return this.getToken(PostgreSQLParser.DETACH, 0); +}; + +Partition_cmdContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPartition_cmd(this); + } +}; + +Partition_cmdContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPartition_cmd(this); + } +}; + +Partition_cmdContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPartition_cmd(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Partition_cmdContext = Partition_cmdContext; + +PostgreSQLParser.prototype.partition_cmd = function() { + + var localctx = new Partition_cmdContext(this, this._ctx, this.state); + this.enterRule(localctx, 100, PostgreSQLParser.RULE_partition_cmd); + try { + this.state = 2183; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ATTACH: + this.enterOuterAlt(localctx, 1); + this.state = 2175; + this.match(PostgreSQLParser.ATTACH); + this.state = 2176; + this.match(PostgreSQLParser.PARTITION); + this.state = 2177; + this.qualified_name(); + this.state = 2178; + this.partitionboundspec(); + break; + case PostgreSQLParser.DETACH: + this.enterOuterAlt(localctx, 2); + this.state = 2180; + this.match(PostgreSQLParser.DETACH); + this.state = 2181; + this.match(PostgreSQLParser.PARTITION); + this.state = 2182; + this.qualified_name(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Index_partition_cmdContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_index_partition_cmd; + return this; +} + +Index_partition_cmdContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Index_partition_cmdContext.prototype.constructor = Index_partition_cmdContext; + +Index_partition_cmdContext.prototype.ATTACH = function() { + return this.getToken(PostgreSQLParser.ATTACH, 0); +}; + +Index_partition_cmdContext.prototype.PARTITION = function() { + return this.getToken(PostgreSQLParser.PARTITION, 0); +}; + +Index_partition_cmdContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +Index_partition_cmdContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIndex_partition_cmd(this); + } +}; + +Index_partition_cmdContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIndex_partition_cmd(this); + } +}; + +Index_partition_cmdContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIndex_partition_cmd(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Index_partition_cmdContext = Index_partition_cmdContext; + +PostgreSQLParser.prototype.index_partition_cmd = function() { + + var localctx = new Index_partition_cmdContext(this, this._ctx, this.state); + this.enterRule(localctx, 102, PostgreSQLParser.RULE_index_partition_cmd); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2185; + this.match(PostgreSQLParser.ATTACH); + this.state = 2186; + this.match(PostgreSQLParser.PARTITION); + this.state = 2187; + this.qualified_name(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_table_cmdContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_table_cmd; + return this; +} + +Alter_table_cmdContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_table_cmdContext.prototype.constructor = Alter_table_cmdContext; + +Alter_table_cmdContext.prototype.ADD_P = function() { + return this.getToken(PostgreSQLParser.ADD_P, 0); +}; + +Alter_table_cmdContext.prototype.columnDef = function() { + return this.getTypedRuleContext(ColumnDefContext,0); +}; + +Alter_table_cmdContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +Alter_table_cmdContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +Alter_table_cmdContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +Alter_table_cmdContext.prototype.COLUMN = function() { + return this.getToken(PostgreSQLParser.COLUMN, 0); +}; + +Alter_table_cmdContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +Alter_table_cmdContext.prototype.opt_column = function() { + return this.getTypedRuleContext(Opt_columnContext,0); +}; + +Alter_table_cmdContext.prototype.colid = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(ColidContext); + } else { + return this.getTypedRuleContext(ColidContext,i); + } +}; + +Alter_table_cmdContext.prototype.alter_column_default = function() { + return this.getTypedRuleContext(Alter_column_defaultContext,0); +}; + +Alter_table_cmdContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +Alter_table_cmdContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +Alter_table_cmdContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +Alter_table_cmdContext.prototype.EXPRESSION = function() { + return this.getToken(PostgreSQLParser.EXPRESSION, 0); +}; + +Alter_table_cmdContext.prototype.STATISTICS = function() { + return this.getToken(PostgreSQLParser.STATISTICS, 0); +}; + +Alter_table_cmdContext.prototype.signediconst = function() { + return this.getTypedRuleContext(SignediconstContext,0); +}; + +Alter_table_cmdContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +Alter_table_cmdContext.prototype.reloptions = function() { + return this.getTypedRuleContext(ReloptionsContext,0); +}; + +Alter_table_cmdContext.prototype.RESET = function() { + return this.getToken(PostgreSQLParser.RESET, 0); +}; + +Alter_table_cmdContext.prototype.STORAGE = function() { + return this.getToken(PostgreSQLParser.STORAGE, 0); +}; + +Alter_table_cmdContext.prototype.GENERATED = function() { + return this.getToken(PostgreSQLParser.GENERATED, 0); +}; + +Alter_table_cmdContext.prototype.generated_when = function() { + return this.getTypedRuleContext(Generated_whenContext,0); +}; + +Alter_table_cmdContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Alter_table_cmdContext.prototype.IDENTITY_P = function() { + return this.getToken(PostgreSQLParser.IDENTITY_P, 0); +}; + +Alter_table_cmdContext.prototype.optparenthesizedseqoptlist = function() { + return this.getTypedRuleContext(OptparenthesizedseqoptlistContext,0); +}; + +Alter_table_cmdContext.prototype.alter_identity_column_option_list = function() { + return this.getTypedRuleContext(Alter_identity_column_option_listContext,0); +}; + +Alter_table_cmdContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +Alter_table_cmdContext.prototype.opt_set_data = function() { + return this.getTypedRuleContext(Opt_set_dataContext,0); +}; + +Alter_table_cmdContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +Alter_table_cmdContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +Alter_table_cmdContext.prototype.opt_collate_clause = function() { + return this.getTypedRuleContext(Opt_collate_clauseContext,0); +}; + +Alter_table_cmdContext.prototype.alter_using = function() { + return this.getTypedRuleContext(Alter_usingContext,0); +}; + +Alter_table_cmdContext.prototype.alter_generic_options = function() { + return this.getTypedRuleContext(Alter_generic_optionsContext,0); +}; + +Alter_table_cmdContext.prototype.tableconstraint = function() { + return this.getTypedRuleContext(TableconstraintContext,0); +}; + +Alter_table_cmdContext.prototype.CONSTRAINT = function() { + return this.getToken(PostgreSQLParser.CONSTRAINT, 0); +}; + +Alter_table_cmdContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Alter_table_cmdContext.prototype.constraintattributespec = function() { + return this.getTypedRuleContext(ConstraintattributespecContext,0); +}; + +Alter_table_cmdContext.prototype.VALIDATE = function() { + return this.getToken(PostgreSQLParser.VALIDATE, 0); +}; + +Alter_table_cmdContext.prototype.WITHOUT = function() { + return this.getToken(PostgreSQLParser.WITHOUT, 0); +}; + +Alter_table_cmdContext.prototype.OIDS = function() { + return this.getToken(PostgreSQLParser.OIDS, 0); +}; + +Alter_table_cmdContext.prototype.CLUSTER = function() { + return this.getToken(PostgreSQLParser.CLUSTER, 0); +}; + +Alter_table_cmdContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +Alter_table_cmdContext.prototype.LOGGED = function() { + return this.getToken(PostgreSQLParser.LOGGED, 0); +}; + +Alter_table_cmdContext.prototype.UNLOGGED = function() { + return this.getToken(PostgreSQLParser.UNLOGGED, 0); +}; + +Alter_table_cmdContext.prototype.ENABLE_P = function() { + return this.getToken(PostgreSQLParser.ENABLE_P, 0); +}; + +Alter_table_cmdContext.prototype.TRIGGER = function() { + return this.getToken(PostgreSQLParser.TRIGGER, 0); +}; + +Alter_table_cmdContext.prototype.ALWAYS = function() { + return this.getToken(PostgreSQLParser.ALWAYS, 0); +}; + +Alter_table_cmdContext.prototype.REPLICA = function() { + return this.getToken(PostgreSQLParser.REPLICA, 0); +}; + +Alter_table_cmdContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Alter_table_cmdContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +Alter_table_cmdContext.prototype.DISABLE_P = function() { + return this.getToken(PostgreSQLParser.DISABLE_P, 0); +}; + +Alter_table_cmdContext.prototype.RULE = function() { + return this.getToken(PostgreSQLParser.RULE, 0); +}; + +Alter_table_cmdContext.prototype.INHERIT = function() { + return this.getToken(PostgreSQLParser.INHERIT, 0); +}; + +Alter_table_cmdContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +Alter_table_cmdContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Alter_table_cmdContext.prototype.OF = function() { + return this.getToken(PostgreSQLParser.OF, 0); +}; + +Alter_table_cmdContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Alter_table_cmdContext.prototype.OWNER = function() { + return this.getToken(PostgreSQLParser.OWNER, 0); +}; + +Alter_table_cmdContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +Alter_table_cmdContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +Alter_table_cmdContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +Alter_table_cmdContext.prototype.replica_identity = function() { + return this.getTypedRuleContext(Replica_identityContext,0); +}; + +Alter_table_cmdContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +Alter_table_cmdContext.prototype.LEVEL = function() { + return this.getToken(PostgreSQLParser.LEVEL, 0); +}; + +Alter_table_cmdContext.prototype.SECURITY = function() { + return this.getToken(PostgreSQLParser.SECURITY, 0); +}; + +Alter_table_cmdContext.prototype.FORCE = function() { + return this.getToken(PostgreSQLParser.FORCE, 0); +}; + +Alter_table_cmdContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_table_cmd(this); + } +}; + +Alter_table_cmdContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_table_cmd(this); + } +}; + +Alter_table_cmdContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_table_cmd(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_table_cmdContext = Alter_table_cmdContext; + +PostgreSQLParser.prototype.alter_table_cmd = function() { + + var localctx = new Alter_table_cmdContext(this, this._ctx, this.state); + this.enterRule(localctx, 104, PostgreSQLParser.RULE_alter_table_cmd); + try { + this.state = 2441; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,49,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2189; + this.match(PostgreSQLParser.ADD_P); + this.state = 2190; + this.columnDef(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 2191; + this.match(PostgreSQLParser.ADD_P); + this.state = 2192; + this.match(PostgreSQLParser.IF_P); + this.state = 2193; + this.match(PostgreSQLParser.NOT); + this.state = 2194; + this.match(PostgreSQLParser.EXISTS); + this.state = 2195; + this.columnDef(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 2196; + this.match(PostgreSQLParser.ADD_P); + this.state = 2197; + this.match(PostgreSQLParser.COLUMN); + this.state = 2198; + this.columnDef(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 2199; + this.match(PostgreSQLParser.ADD_P); + this.state = 2200; + this.match(PostgreSQLParser.COLUMN); + this.state = 2201; + this.match(PostgreSQLParser.IF_P); + this.state = 2202; + this.match(PostgreSQLParser.NOT); + this.state = 2203; + this.match(PostgreSQLParser.EXISTS); + this.state = 2204; + this.columnDef(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 2205; + this.match(PostgreSQLParser.ALTER); + this.state = 2206; + this.opt_column(); + this.state = 2207; + this.colid(); + this.state = 2208; + this.alter_column_default(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 2210; + this.match(PostgreSQLParser.ALTER); + this.state = 2211; + this.opt_column(); + this.state = 2212; + this.colid(); + this.state = 2213; + this.match(PostgreSQLParser.DROP); + this.state = 2214; + this.match(PostgreSQLParser.NOT); + this.state = 2215; + this.match(PostgreSQLParser.NULL_P); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 2217; + this.match(PostgreSQLParser.ALTER); + this.state = 2218; + this.opt_column(); + this.state = 2219; + this.colid(); + this.state = 2220; + this.match(PostgreSQLParser.SET); + this.state = 2221; + this.match(PostgreSQLParser.NOT); + this.state = 2222; + this.match(PostgreSQLParser.NULL_P); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 2224; + this.match(PostgreSQLParser.ALTER); + this.state = 2225; + this.opt_column(); + this.state = 2226; + this.colid(); + this.state = 2227; + this.match(PostgreSQLParser.DROP); + this.state = 2228; + this.match(PostgreSQLParser.EXPRESSION); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 2230; + this.match(PostgreSQLParser.ALTER); + this.state = 2231; + this.opt_column(); + this.state = 2232; + this.colid(); + this.state = 2233; + this.match(PostgreSQLParser.DROP); + this.state = 2234; + this.match(PostgreSQLParser.EXPRESSION); + this.state = 2235; + this.match(PostgreSQLParser.IF_P); + this.state = 2236; + this.match(PostgreSQLParser.EXISTS); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 2238; + this.match(PostgreSQLParser.ALTER); + this.state = 2239; + this.opt_column(); + this.state = 2240; + this.colid(); + this.state = 2241; + this.match(PostgreSQLParser.SET); + this.state = 2242; + this.match(PostgreSQLParser.STATISTICS); + this.state = 2243; + this.signediconst(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 2245; + this.match(PostgreSQLParser.ALTER); + this.state = 2246; + this.opt_column(); + this.state = 2247; + this.iconst(); + this.state = 2248; + this.match(PostgreSQLParser.SET); + this.state = 2249; + this.match(PostgreSQLParser.STATISTICS); + this.state = 2250; + this.signediconst(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 2252; + this.match(PostgreSQLParser.ALTER); + this.state = 2253; + this.opt_column(); + this.state = 2254; + this.colid(); + this.state = 2255; + this.match(PostgreSQLParser.SET); + this.state = 2256; + this.reloptions(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 2258; + this.match(PostgreSQLParser.ALTER); + this.state = 2259; + this.opt_column(); + this.state = 2260; + this.colid(); + this.state = 2261; + this.match(PostgreSQLParser.RESET); + this.state = 2262; + this.reloptions(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 2264; + this.match(PostgreSQLParser.ALTER); + this.state = 2265; + this.opt_column(); + this.state = 2266; + this.colid(); + this.state = 2267; + this.match(PostgreSQLParser.SET); + this.state = 2268; + this.match(PostgreSQLParser.STORAGE); + this.state = 2269; + this.colid(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 2271; + this.match(PostgreSQLParser.ALTER); + this.state = 2272; + this.opt_column(); + this.state = 2273; + this.colid(); + this.state = 2274; + this.match(PostgreSQLParser.ADD_P); + this.state = 2275; + this.match(PostgreSQLParser.GENERATED); + this.state = 2276; + this.generated_when(); + this.state = 2277; + this.match(PostgreSQLParser.AS); + this.state = 2278; + this.match(PostgreSQLParser.IDENTITY_P); + this.state = 2279; + this.optparenthesizedseqoptlist(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 2281; + this.match(PostgreSQLParser.ALTER); + this.state = 2282; + this.opt_column(); + this.state = 2283; + this.colid(); + this.state = 2284; + this.alter_identity_column_option_list(); + break; + + case 17: + this.enterOuterAlt(localctx, 17); + this.state = 2286; + this.match(PostgreSQLParser.ALTER); + this.state = 2287; + this.opt_column(); + this.state = 2288; + this.colid(); + this.state = 2289; + this.match(PostgreSQLParser.DROP); + this.state = 2290; + this.match(PostgreSQLParser.IDENTITY_P); + break; + + case 18: + this.enterOuterAlt(localctx, 18); + this.state = 2292; + this.match(PostgreSQLParser.ALTER); + this.state = 2293; + this.opt_column(); + this.state = 2294; + this.colid(); + this.state = 2295; + this.match(PostgreSQLParser.DROP); + this.state = 2296; + this.match(PostgreSQLParser.IDENTITY_P); + this.state = 2297; + this.match(PostgreSQLParser.IF_P); + this.state = 2298; + this.match(PostgreSQLParser.EXISTS); + break; + + case 19: + this.enterOuterAlt(localctx, 19); + this.state = 2300; + this.match(PostgreSQLParser.DROP); + this.state = 2301; + this.opt_column(); + this.state = 2302; + this.match(PostgreSQLParser.IF_P); + this.state = 2303; + this.match(PostgreSQLParser.EXISTS); + this.state = 2304; + this.colid(); + this.state = 2305; + this.opt_drop_behavior(); + break; + + case 20: + this.enterOuterAlt(localctx, 20); + this.state = 2307; + this.match(PostgreSQLParser.DROP); + this.state = 2308; + this.opt_column(); + this.state = 2309; + this.colid(); + this.state = 2310; + this.opt_drop_behavior(); + break; + + case 21: + this.enterOuterAlt(localctx, 21); + this.state = 2312; + this.match(PostgreSQLParser.ALTER); + this.state = 2313; + this.opt_column(); + this.state = 2314; + this.colid(); + this.state = 2315; + this.opt_set_data(); + this.state = 2316; + this.match(PostgreSQLParser.TYPE_P); + this.state = 2317; + this.typename(); + this.state = 2318; + this.opt_collate_clause(); + this.state = 2319; + this.alter_using(); + break; + + case 22: + this.enterOuterAlt(localctx, 22); + this.state = 2321; + this.match(PostgreSQLParser.ALTER); + this.state = 2322; + this.opt_column(); + this.state = 2323; + this.colid(); + this.state = 2324; + this.alter_generic_options(); + break; + + case 23: + this.enterOuterAlt(localctx, 23); + this.state = 2326; + this.match(PostgreSQLParser.ADD_P); + this.state = 2327; + this.tableconstraint(); + break; + + case 24: + this.enterOuterAlt(localctx, 24); + this.state = 2328; + this.match(PostgreSQLParser.ALTER); + this.state = 2329; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 2330; + this.name(); + this.state = 2331; + this.constraintattributespec(); + break; + + case 25: + this.enterOuterAlt(localctx, 25); + this.state = 2333; + this.match(PostgreSQLParser.VALIDATE); + this.state = 2334; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 2335; + this.name(); + break; + + case 26: + this.enterOuterAlt(localctx, 26); + this.state = 2336; + this.match(PostgreSQLParser.DROP); + this.state = 2337; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 2338; + this.match(PostgreSQLParser.IF_P); + this.state = 2339; + this.match(PostgreSQLParser.EXISTS); + this.state = 2340; + this.name(); + this.state = 2341; + this.opt_drop_behavior(); + break; + + case 27: + this.enterOuterAlt(localctx, 27); + this.state = 2343; + this.match(PostgreSQLParser.DROP); + this.state = 2344; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 2345; + this.name(); + this.state = 2346; + this.opt_drop_behavior(); + break; + + case 28: + this.enterOuterAlt(localctx, 28); + this.state = 2348; + this.match(PostgreSQLParser.SET); + this.state = 2349; + this.match(PostgreSQLParser.WITHOUT); + this.state = 2350; + this.match(PostgreSQLParser.OIDS); + break; + + case 29: + this.enterOuterAlt(localctx, 29); + this.state = 2351; + this.match(PostgreSQLParser.CLUSTER); + this.state = 2352; + this.match(PostgreSQLParser.ON); + this.state = 2353; + this.name(); + break; + + case 30: + this.enterOuterAlt(localctx, 30); + this.state = 2354; + this.match(PostgreSQLParser.SET); + this.state = 2355; + this.match(PostgreSQLParser.WITHOUT); + this.state = 2356; + this.match(PostgreSQLParser.CLUSTER); + break; + + case 31: + this.enterOuterAlt(localctx, 31); + this.state = 2357; + this.match(PostgreSQLParser.SET); + this.state = 2358; + this.match(PostgreSQLParser.LOGGED); + break; + + case 32: + this.enterOuterAlt(localctx, 32); + this.state = 2359; + this.match(PostgreSQLParser.SET); + this.state = 2360; + this.match(PostgreSQLParser.UNLOGGED); + break; + + case 33: + this.enterOuterAlt(localctx, 33); + this.state = 2361; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 2362; + this.match(PostgreSQLParser.TRIGGER); + this.state = 2363; + this.name(); + break; + + case 34: + this.enterOuterAlt(localctx, 34); + this.state = 2364; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 2365; + this.match(PostgreSQLParser.ALWAYS); + this.state = 2366; + this.match(PostgreSQLParser.TRIGGER); + this.state = 2367; + this.name(); + break; + + case 35: + this.enterOuterAlt(localctx, 35); + this.state = 2368; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 2369; + this.match(PostgreSQLParser.REPLICA); + this.state = 2370; + this.match(PostgreSQLParser.TRIGGER); + this.state = 2371; + this.name(); + break; + + case 36: + this.enterOuterAlt(localctx, 36); + this.state = 2372; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 2373; + this.match(PostgreSQLParser.TRIGGER); + this.state = 2374; + this.match(PostgreSQLParser.ALL); + break; + + case 37: + this.enterOuterAlt(localctx, 37); + this.state = 2375; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 2376; + this.match(PostgreSQLParser.TRIGGER); + this.state = 2377; + this.match(PostgreSQLParser.USER); + break; + + case 38: + this.enterOuterAlt(localctx, 38); + this.state = 2378; + this.match(PostgreSQLParser.DISABLE_P); + this.state = 2379; + this.match(PostgreSQLParser.TRIGGER); + this.state = 2380; + this.name(); + break; + + case 39: + this.enterOuterAlt(localctx, 39); + this.state = 2381; + this.match(PostgreSQLParser.DISABLE_P); + this.state = 2382; + this.match(PostgreSQLParser.TRIGGER); + this.state = 2383; + this.match(PostgreSQLParser.ALL); + break; + + case 40: + this.enterOuterAlt(localctx, 40); + this.state = 2384; + this.match(PostgreSQLParser.DISABLE_P); + this.state = 2385; + this.match(PostgreSQLParser.TRIGGER); + this.state = 2386; + this.match(PostgreSQLParser.USER); + break; + + case 41: + this.enterOuterAlt(localctx, 41); + this.state = 2387; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 2388; + this.match(PostgreSQLParser.RULE); + this.state = 2389; + this.name(); + break; + + case 42: + this.enterOuterAlt(localctx, 42); + this.state = 2390; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 2391; + this.match(PostgreSQLParser.ALWAYS); + this.state = 2392; + this.match(PostgreSQLParser.RULE); + this.state = 2393; + this.name(); + break; + + case 43: + this.enterOuterAlt(localctx, 43); + this.state = 2394; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 2395; + this.match(PostgreSQLParser.REPLICA); + this.state = 2396; + this.match(PostgreSQLParser.RULE); + this.state = 2397; + this.name(); + break; + + case 44: + this.enterOuterAlt(localctx, 44); + this.state = 2398; + this.match(PostgreSQLParser.DISABLE_P); + this.state = 2399; + this.match(PostgreSQLParser.RULE); + this.state = 2400; + this.name(); + break; + + case 45: + this.enterOuterAlt(localctx, 45); + this.state = 2401; + this.match(PostgreSQLParser.INHERIT); + this.state = 2402; + this.qualified_name(); + break; + + case 46: + this.enterOuterAlt(localctx, 46); + this.state = 2403; + this.match(PostgreSQLParser.NO); + this.state = 2404; + this.match(PostgreSQLParser.INHERIT); + this.state = 2405; + this.qualified_name(); + break; + + case 47: + this.enterOuterAlt(localctx, 47); + this.state = 2406; + this.match(PostgreSQLParser.OF); + this.state = 2407; + this.any_name(); + break; + + case 48: + this.enterOuterAlt(localctx, 48); + this.state = 2408; + this.match(PostgreSQLParser.NOT); + this.state = 2409; + this.match(PostgreSQLParser.OF); + break; + + case 49: + this.enterOuterAlt(localctx, 49); + this.state = 2410; + this.match(PostgreSQLParser.OWNER); + this.state = 2411; + this.match(PostgreSQLParser.TO); + this.state = 2412; + this.rolespec(); + break; + + case 50: + this.enterOuterAlt(localctx, 50); + this.state = 2413; + this.match(PostgreSQLParser.SET); + this.state = 2414; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 2415; + this.name(); + break; + + case 51: + this.enterOuterAlt(localctx, 51); + this.state = 2416; + this.match(PostgreSQLParser.SET); + this.state = 2417; + this.reloptions(); + break; + + case 52: + this.enterOuterAlt(localctx, 52); + this.state = 2418; + this.match(PostgreSQLParser.RESET); + this.state = 2419; + this.reloptions(); + break; + + case 53: + this.enterOuterAlt(localctx, 53); + this.state = 2420; + this.match(PostgreSQLParser.REPLICA); + this.state = 2421; + this.match(PostgreSQLParser.IDENTITY_P); + this.state = 2422; + this.replica_identity(); + break; + + case 54: + this.enterOuterAlt(localctx, 54); + this.state = 2423; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 2424; + this.match(PostgreSQLParser.ROW); + this.state = 2425; + this.match(PostgreSQLParser.LEVEL); + this.state = 2426; + this.match(PostgreSQLParser.SECURITY); + break; + + case 55: + this.enterOuterAlt(localctx, 55); + this.state = 2427; + this.match(PostgreSQLParser.DISABLE_P); + this.state = 2428; + this.match(PostgreSQLParser.ROW); + this.state = 2429; + this.match(PostgreSQLParser.LEVEL); + this.state = 2430; + this.match(PostgreSQLParser.SECURITY); + break; + + case 56: + this.enterOuterAlt(localctx, 56); + this.state = 2431; + this.match(PostgreSQLParser.FORCE); + this.state = 2432; + this.match(PostgreSQLParser.ROW); + this.state = 2433; + this.match(PostgreSQLParser.LEVEL); + this.state = 2434; + this.match(PostgreSQLParser.SECURITY); + break; + + case 57: + this.enterOuterAlt(localctx, 57); + this.state = 2435; + this.match(PostgreSQLParser.NO); + this.state = 2436; + this.match(PostgreSQLParser.FORCE); + this.state = 2437; + this.match(PostgreSQLParser.ROW); + this.state = 2438; + this.match(PostgreSQLParser.LEVEL); + this.state = 2439; + this.match(PostgreSQLParser.SECURITY); + break; + + case 58: + this.enterOuterAlt(localctx, 58); + this.state = 2440; + this.alter_generic_options(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_column_defaultContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_column_default; + return this; +} + +Alter_column_defaultContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_column_defaultContext.prototype.constructor = Alter_column_defaultContext; + +Alter_column_defaultContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +Alter_column_defaultContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Alter_column_defaultContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Alter_column_defaultContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +Alter_column_defaultContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_column_default(this); + } +}; + +Alter_column_defaultContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_column_default(this); + } +}; + +Alter_column_defaultContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_column_default(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_column_defaultContext = Alter_column_defaultContext; + +PostgreSQLParser.prototype.alter_column_default = function() { + + var localctx = new Alter_column_defaultContext(this, this._ctx, this.state); + this.enterRule(localctx, 106, PostgreSQLParser.RULE_alter_column_default); + try { + this.state = 2448; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SET: + this.enterOuterAlt(localctx, 1); + this.state = 2443; + this.match(PostgreSQLParser.SET); + this.state = 2444; + this.match(PostgreSQLParser.DEFAULT); + this.state = 2445; + this.a_expr(); + break; + case PostgreSQLParser.DROP: + this.enterOuterAlt(localctx, 2); + this.state = 2446; + this.match(PostgreSQLParser.DROP); + this.state = 2447; + this.match(PostgreSQLParser.DEFAULT); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_drop_behaviorContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_drop_behavior; + return this; +} + +Opt_drop_behaviorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_drop_behaviorContext.prototype.constructor = Opt_drop_behaviorContext; + +Opt_drop_behaviorContext.prototype.CASCADE = function() { + return this.getToken(PostgreSQLParser.CASCADE, 0); +}; + +Opt_drop_behaviorContext.prototype.RESTRICT = function() { + return this.getToken(PostgreSQLParser.RESTRICT, 0); +}; + +Opt_drop_behaviorContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_drop_behavior(this); + } +}; + +Opt_drop_behaviorContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_drop_behavior(this); + } +}; + +Opt_drop_behaviorContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_drop_behavior(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_drop_behaviorContext = Opt_drop_behaviorContext; + +PostgreSQLParser.prototype.opt_drop_behavior = function() { + + var localctx = new Opt_drop_behaviorContext(this, this._ctx, this.state); + this.enterRule(localctx, 108, PostgreSQLParser.RULE_opt_drop_behavior); + try { + this.state = 2453; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CASCADE: + this.enterOuterAlt(localctx, 1); + this.state = 2450; + this.match(PostgreSQLParser.CASCADE); + break; + case PostgreSQLParser.RESTRICT: + this.enterOuterAlt(localctx, 2); + this.state = 2451; + this.match(PostgreSQLParser.RESTRICT); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_collate_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_collate_clause; + return this; +} + +Opt_collate_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_collate_clauseContext.prototype.constructor = Opt_collate_clauseContext; + +Opt_collate_clauseContext.prototype.COLLATE = function() { + return this.getToken(PostgreSQLParser.COLLATE, 0); +}; + +Opt_collate_clauseContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Opt_collate_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_collate_clause(this); + } +}; + +Opt_collate_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_collate_clause(this); + } +}; + +Opt_collate_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_collate_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_collate_clauseContext = Opt_collate_clauseContext; + +PostgreSQLParser.prototype.opt_collate_clause = function() { + + var localctx = new Opt_collate_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 110, PostgreSQLParser.RULE_opt_collate_clause); + try { + this.state = 2458; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.COLLATE: + this.enterOuterAlt(localctx, 1); + this.state = 2455; + this.match(PostgreSQLParser.COLLATE); + this.state = 2456; + this.any_name(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.USING: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_usingContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_using; + return this; +} + +Alter_usingContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_usingContext.prototype.constructor = Alter_usingContext; + +Alter_usingContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Alter_usingContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Alter_usingContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_using(this); + } +}; + +Alter_usingContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_using(this); + } +}; + +Alter_usingContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_using(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_usingContext = Alter_usingContext; + +PostgreSQLParser.prototype.alter_using = function() { + + var localctx = new Alter_usingContext(this, this._ctx, this.state); + this.enterRule(localctx, 112, PostgreSQLParser.RULE_alter_using); + try { + this.state = 2463; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + this.state = 2460; + this.match(PostgreSQLParser.USING); + this.state = 2461; + this.a_expr(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Replica_identityContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_replica_identity; + return this; +} + +Replica_identityContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Replica_identityContext.prototype.constructor = Replica_identityContext; + +Replica_identityContext.prototype.NOTHING = function() { + return this.getToken(PostgreSQLParser.NOTHING, 0); +}; + +Replica_identityContext.prototype.FULL = function() { + return this.getToken(PostgreSQLParser.FULL, 0); +}; + +Replica_identityContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Replica_identityContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Replica_identityContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +Replica_identityContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Replica_identityContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReplica_identity(this); + } +}; + +Replica_identityContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReplica_identity(this); + } +}; + +Replica_identityContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReplica_identity(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Replica_identityContext = Replica_identityContext; + +PostgreSQLParser.prototype.replica_identity = function() { + + var localctx = new Replica_identityContext(this, this._ctx, this.state); + this.enterRule(localctx, 114, PostgreSQLParser.RULE_replica_identity); + try { + this.state = 2471; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NOTHING: + this.enterOuterAlt(localctx, 1); + this.state = 2465; + this.match(PostgreSQLParser.NOTHING); + break; + case PostgreSQLParser.FULL: + this.enterOuterAlt(localctx, 2); + this.state = 2466; + this.match(PostgreSQLParser.FULL); + break; + case PostgreSQLParser.DEFAULT: + this.enterOuterAlt(localctx, 3); + this.state = 2467; + this.match(PostgreSQLParser.DEFAULT); + break; + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 4); + this.state = 2468; + this.match(PostgreSQLParser.USING); + this.state = 2469; + this.match(PostgreSQLParser.INDEX); + this.state = 2470; + this.name(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ReloptionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reloptions; + return this; +} + +ReloptionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ReloptionsContext.prototype.constructor = ReloptionsContext; + +ReloptionsContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +ReloptionsContext.prototype.reloption_list = function() { + return this.getTypedRuleContext(Reloption_listContext,0); +}; + +ReloptionsContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +ReloptionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReloptions(this); + } +}; + +ReloptionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReloptions(this); + } +}; + +ReloptionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReloptions(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ReloptionsContext = ReloptionsContext; + +PostgreSQLParser.prototype.reloptions = function() { + + var localctx = new ReloptionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 116, PostgreSQLParser.RULE_reloptions); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2473; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2474; + this.reloption_list(); + this.state = 2475; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_reloptionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_reloptions; + return this; +} + +Opt_reloptionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_reloptionsContext.prototype.constructor = Opt_reloptionsContext; + +Opt_reloptionsContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Opt_reloptionsContext.prototype.reloptions = function() { + return this.getTypedRuleContext(ReloptionsContext,0); +}; + +Opt_reloptionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_reloptions(this); + } +}; + +Opt_reloptionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_reloptions(this); + } +}; + +Opt_reloptionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_reloptions(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_reloptionsContext = Opt_reloptionsContext; + +PostgreSQLParser.prototype.opt_reloptions = function() { + + var localctx = new Opt_reloptionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 118, PostgreSQLParser.RULE_opt_reloptions); + try { + this.state = 2480; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,55,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2477; + this.match(PostgreSQLParser.WITH); + this.state = 2478; + this.reloptions(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Reloption_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reloption_list; + return this; +} + +Reloption_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Reloption_listContext.prototype.constructor = Reloption_listContext; + +Reloption_listContext.prototype.reloption_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Reloption_elemContext); + } else { + return this.getTypedRuleContext(Reloption_elemContext,i); + } +}; + +Reloption_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Reloption_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReloption_list(this); + } +}; + +Reloption_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReloption_list(this); + } +}; + +Reloption_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReloption_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Reloption_listContext = Reloption_listContext; + +PostgreSQLParser.prototype.reloption_list = function() { + + var localctx = new Reloption_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 120, PostgreSQLParser.RULE_reloption_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2482; + this.reloption_elem(); + this.state = 2487; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 2483; + this.match(PostgreSQLParser.COMMA); + this.state = 2484; + this.reloption_elem(); + this.state = 2489; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Reloption_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reloption_elem; + return this; +} + +Reloption_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Reloption_elemContext.prototype.constructor = Reloption_elemContext; + +Reloption_elemContext.prototype.collabel = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(CollabelContext); + } else { + return this.getTypedRuleContext(CollabelContext,i); + } +}; + +Reloption_elemContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +Reloption_elemContext.prototype.def_arg = function() { + return this.getTypedRuleContext(Def_argContext,0); +}; + +Reloption_elemContext.prototype.DOT = function() { + return this.getToken(PostgreSQLParser.DOT, 0); +}; + +Reloption_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReloption_elem(this); + } +}; + +Reloption_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReloption_elem(this); + } +}; + +Reloption_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReloption_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Reloption_elemContext = Reloption_elemContext; + +PostgreSQLParser.prototype.reloption_elem = function() { + + var localctx = new Reloption_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 122, PostgreSQLParser.RULE_reloption_elem); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2490; + this.collabel(); + this.state = 2499; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case PostgreSQLParser.EQUAL: + this.state = 2491; + this.match(PostgreSQLParser.EQUAL); + this.state = 2492; + this.def_arg(); + break; + case PostgreSQLParser.DOT: + this.state = 2493; + this.match(PostgreSQLParser.DOT); + this.state = 2494; + this.collabel(); + this.state = 2497; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.EQUAL) { + this.state = 2495; + this.match(PostgreSQLParser.EQUAL); + this.state = 2496; + this.def_arg(); + } + + break; + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + break; + default: + break; + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_identity_column_option_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_identity_column_option_list; + return this; +} + +Alter_identity_column_option_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_identity_column_option_listContext.prototype.constructor = Alter_identity_column_option_listContext; + +Alter_identity_column_option_listContext.prototype.alter_identity_column_option = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Alter_identity_column_optionContext); + } else { + return this.getTypedRuleContext(Alter_identity_column_optionContext,i); + } +}; + +Alter_identity_column_option_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_identity_column_option_list(this); + } +}; + +Alter_identity_column_option_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_identity_column_option_list(this); + } +}; + +Alter_identity_column_option_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_identity_column_option_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_identity_column_option_listContext = Alter_identity_column_option_listContext; + +PostgreSQLParser.prototype.alter_identity_column_option_list = function() { + + var localctx = new Alter_identity_column_option_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 124, PostgreSQLParser.RULE_alter_identity_column_option_list); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2502; + this._errHandler.sync(this); + var _alt = 1; + do { + switch (_alt) { + case 1: + this.state = 2501; + this.alter_identity_column_option(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 2504; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,59, this._ctx); + } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER ); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_identity_column_optionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_identity_column_option; + return this; +} + +Alter_identity_column_optionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_identity_column_optionContext.prototype.constructor = Alter_identity_column_optionContext; + +Alter_identity_column_optionContext.prototype.RESTART = function() { + return this.getToken(PostgreSQLParser.RESTART, 0); +}; + +Alter_identity_column_optionContext.prototype.opt_with = function() { + return this.getTypedRuleContext(Opt_withContext,0); +}; + +Alter_identity_column_optionContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +Alter_identity_column_optionContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +Alter_identity_column_optionContext.prototype.seqoptelem = function() { + return this.getTypedRuleContext(SeqoptelemContext,0); +}; + +Alter_identity_column_optionContext.prototype.GENERATED = function() { + return this.getToken(PostgreSQLParser.GENERATED, 0); +}; + +Alter_identity_column_optionContext.prototype.generated_when = function() { + return this.getTypedRuleContext(Generated_whenContext,0); +}; + +Alter_identity_column_optionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_identity_column_option(this); + } +}; + +Alter_identity_column_optionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_identity_column_option(this); + } +}; + +Alter_identity_column_optionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_identity_column_option(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_identity_column_optionContext = Alter_identity_column_optionContext; + +PostgreSQLParser.prototype.alter_identity_column_option = function() { + + var localctx = new Alter_identity_column_optionContext(this, this._ctx, this.state); + this.enterRule(localctx, 126, PostgreSQLParser.RULE_alter_identity_column_option); + try { + this.state = 2518; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.RESTART: + this.enterOuterAlt(localctx, 1); + this.state = 2506; + this.match(PostgreSQLParser.RESTART); + this.state = 2510; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,60,this._ctx); + if(la_===1) { + this.state = 2507; + this.opt_with(); + this.state = 2508; + this.numericonly(); + + } + break; + case PostgreSQLParser.SET: + this.enterOuterAlt(localctx, 2); + this.state = 2512; + this.match(PostgreSQLParser.SET); + this.state = 2516; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AS: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.NO: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.START: + this.state = 2513; + this.seqoptelem(); + break; + case PostgreSQLParser.GENERATED: + this.state = 2514; + this.match(PostgreSQLParser.GENERATED); + this.state = 2515; + this.generated_when(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function PartitionboundspecContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_partitionboundspec; + return this; +} + +PartitionboundspecContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +PartitionboundspecContext.prototype.constructor = PartitionboundspecContext; + +PartitionboundspecContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +PartitionboundspecContext.prototype.VALUES = function() { + return this.getToken(PostgreSQLParser.VALUES, 0); +}; + +PartitionboundspecContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +PartitionboundspecContext.prototype.OPEN_PAREN = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.OPEN_PAREN); + } else { + return this.getToken(PostgreSQLParser.OPEN_PAREN, i); + } +}; + + +PartitionboundspecContext.prototype.hash_partbound = function() { + return this.getTypedRuleContext(Hash_partboundContext,0); +}; + +PartitionboundspecContext.prototype.CLOSE_PAREN = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.CLOSE_PAREN); + } else { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, i); + } +}; + + +PartitionboundspecContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +PartitionboundspecContext.prototype.expr_list = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Expr_listContext); + } else { + return this.getTypedRuleContext(Expr_listContext,i); + } +}; + +PartitionboundspecContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +PartitionboundspecContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +PartitionboundspecContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +PartitionboundspecContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPartitionboundspec(this); + } +}; + +PartitionboundspecContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPartitionboundspec(this); + } +}; + +PartitionboundspecContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPartitionboundspec(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.PartitionboundspecContext = PartitionboundspecContext; + +PostgreSQLParser.prototype.partitionboundspec = function() { + + var localctx = new PartitionboundspecContext(this, this._ctx, this.state); + this.enterRule(localctx, 128, PostgreSQLParser.RULE_partitionboundspec); + try { + this.state = 2546; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,63,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2520; + this.match(PostgreSQLParser.FOR); + this.state = 2521; + this.match(PostgreSQLParser.VALUES); + this.state = 2522; + this.match(PostgreSQLParser.WITH); + this.state = 2523; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2524; + this.hash_partbound(); + this.state = 2525; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 2527; + this.match(PostgreSQLParser.FOR); + this.state = 2528; + this.match(PostgreSQLParser.VALUES); + this.state = 2529; + this.match(PostgreSQLParser.IN_P); + this.state = 2530; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2531; + this.expr_list(); + this.state = 2532; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 2534; + this.match(PostgreSQLParser.FOR); + this.state = 2535; + this.match(PostgreSQLParser.VALUES); + this.state = 2536; + this.match(PostgreSQLParser.FROM); + this.state = 2537; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2538; + this.expr_list(); + this.state = 2539; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 2540; + this.match(PostgreSQLParser.TO); + this.state = 2541; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2542; + this.expr_list(); + this.state = 2543; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 2545; + this.match(PostgreSQLParser.DEFAULT); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Hash_partbound_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_hash_partbound_elem; + return this; +} + +Hash_partbound_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Hash_partbound_elemContext.prototype.constructor = Hash_partbound_elemContext; + +Hash_partbound_elemContext.prototype.nonreservedword = function() { + return this.getTypedRuleContext(NonreservedwordContext,0); +}; + +Hash_partbound_elemContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +Hash_partbound_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterHash_partbound_elem(this); + } +}; + +Hash_partbound_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitHash_partbound_elem(this); + } +}; + +Hash_partbound_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitHash_partbound_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Hash_partbound_elemContext = Hash_partbound_elemContext; + +PostgreSQLParser.prototype.hash_partbound_elem = function() { + + var localctx = new Hash_partbound_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 130, PostgreSQLParser.RULE_hash_partbound_elem); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2548; + this.nonreservedword(); + this.state = 2549; + this.iconst(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Hash_partboundContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_hash_partbound; + return this; +} + +Hash_partboundContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Hash_partboundContext.prototype.constructor = Hash_partboundContext; + +Hash_partboundContext.prototype.hash_partbound_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Hash_partbound_elemContext); + } else { + return this.getTypedRuleContext(Hash_partbound_elemContext,i); + } +}; + +Hash_partboundContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Hash_partboundContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterHash_partbound(this); + } +}; + +Hash_partboundContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitHash_partbound(this); + } +}; + +Hash_partboundContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitHash_partbound(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Hash_partboundContext = Hash_partboundContext; + +PostgreSQLParser.prototype.hash_partbound = function() { + + var localctx = new Hash_partboundContext(this, this._ctx, this.state); + this.enterRule(localctx, 132, PostgreSQLParser.RULE_hash_partbound); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2551; + this.hash_partbound_elem(); + this.state = 2556; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 2552; + this.match(PostgreSQLParser.COMMA); + this.state = 2553; + this.hash_partbound_elem(); + this.state = 2558; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltercompositetypestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altercompositetypestmt; + return this; +} + +AltercompositetypestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltercompositetypestmtContext.prototype.constructor = AltercompositetypestmtContext; + +AltercompositetypestmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AltercompositetypestmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +AltercompositetypestmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AltercompositetypestmtContext.prototype.alter_type_cmds = function() { + return this.getTypedRuleContext(Alter_type_cmdsContext,0); +}; + +AltercompositetypestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltercompositetypestmt(this); + } +}; + +AltercompositetypestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltercompositetypestmt(this); + } +}; + +AltercompositetypestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltercompositetypestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltercompositetypestmtContext = AltercompositetypestmtContext; + +PostgreSQLParser.prototype.altercompositetypestmt = function() { + + var localctx = new AltercompositetypestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 134, PostgreSQLParser.RULE_altercompositetypestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2559; + this.match(PostgreSQLParser.ALTER); + this.state = 2560; + this.match(PostgreSQLParser.TYPE_P); + this.state = 2561; + this.any_name(); + this.state = 2562; + this.alter_type_cmds(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_type_cmdsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_type_cmds; + return this; +} + +Alter_type_cmdsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_type_cmdsContext.prototype.constructor = Alter_type_cmdsContext; + +Alter_type_cmdsContext.prototype.alter_type_cmd = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Alter_type_cmdContext); + } else { + return this.getTypedRuleContext(Alter_type_cmdContext,i); + } +}; + +Alter_type_cmdsContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Alter_type_cmdsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_type_cmds(this); + } +}; + +Alter_type_cmdsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_type_cmds(this); + } +}; + +Alter_type_cmdsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_type_cmds(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_type_cmdsContext = Alter_type_cmdsContext; + +PostgreSQLParser.prototype.alter_type_cmds = function() { + + var localctx = new Alter_type_cmdsContext(this, this._ctx, this.state); + this.enterRule(localctx, 136, PostgreSQLParser.RULE_alter_type_cmds); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2564; + this.alter_type_cmd(); + this.state = 2569; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 2565; + this.match(PostgreSQLParser.COMMA); + this.state = 2566; + this.alter_type_cmd(); + this.state = 2571; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_type_cmdContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_type_cmd; + return this; +} + +Alter_type_cmdContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_type_cmdContext.prototype.constructor = Alter_type_cmdContext; + +Alter_type_cmdContext.prototype.ADD_P = function() { + return this.getToken(PostgreSQLParser.ADD_P, 0); +}; + +Alter_type_cmdContext.prototype.ATTRIBUTE = function() { + return this.getToken(PostgreSQLParser.ATTRIBUTE, 0); +}; + +Alter_type_cmdContext.prototype.tablefuncelement = function() { + return this.getTypedRuleContext(TablefuncelementContext,0); +}; + +Alter_type_cmdContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +Alter_type_cmdContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +Alter_type_cmdContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Alter_type_cmdContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +Alter_type_cmdContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +Alter_type_cmdContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +Alter_type_cmdContext.prototype.opt_set_data = function() { + return this.getTypedRuleContext(Opt_set_dataContext,0); +}; + +Alter_type_cmdContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +Alter_type_cmdContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +Alter_type_cmdContext.prototype.opt_collate_clause = function() { + return this.getTypedRuleContext(Opt_collate_clauseContext,0); +}; + +Alter_type_cmdContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_type_cmd(this); + } +}; + +Alter_type_cmdContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_type_cmd(this); + } +}; + +Alter_type_cmdContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_type_cmd(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_type_cmdContext = Alter_type_cmdContext; + +PostgreSQLParser.prototype.alter_type_cmd = function() { + + var localctx = new Alter_type_cmdContext(this, this._ctx, this.state); + this.enterRule(localctx, 138, PostgreSQLParser.RULE_alter_type_cmd); + try { + this.state = 2595; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ADD_P: + this.enterOuterAlt(localctx, 1); + this.state = 2572; + this.match(PostgreSQLParser.ADD_P); + this.state = 2573; + this.match(PostgreSQLParser.ATTRIBUTE); + this.state = 2574; + this.tablefuncelement(); + this.state = 2575; + this.opt_drop_behavior(); + break; + case PostgreSQLParser.DROP: + this.enterOuterAlt(localctx, 2); + this.state = 2577; + this.match(PostgreSQLParser.DROP); + this.state = 2578; + this.match(PostgreSQLParser.ATTRIBUTE); + this.state = 2581; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,66,this._ctx); + if(la_===1) { + this.state = 2579; + this.match(PostgreSQLParser.IF_P); + this.state = 2580; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 2583; + this.colid(); + this.state = 2584; + this.opt_drop_behavior(); + break; + case PostgreSQLParser.ALTER: + this.enterOuterAlt(localctx, 3); + this.state = 2586; + this.match(PostgreSQLParser.ALTER); + this.state = 2587; + this.match(PostgreSQLParser.ATTRIBUTE); + this.state = 2588; + this.colid(); + this.state = 2589; + this.opt_set_data(); + this.state = 2590; + this.match(PostgreSQLParser.TYPE_P); + this.state = 2591; + this.typename(); + this.state = 2592; + this.opt_collate_clause(); + this.state = 2593; + this.opt_drop_behavior(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CloseportalstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_closeportalstmt; + return this; +} + +CloseportalstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CloseportalstmtContext.prototype.constructor = CloseportalstmtContext; + +CloseportalstmtContext.prototype.CLOSE = function() { + return this.getToken(PostgreSQLParser.CLOSE, 0); +}; + +CloseportalstmtContext.prototype.cursor_name = function() { + return this.getTypedRuleContext(Cursor_nameContext,0); +}; + +CloseportalstmtContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +CloseportalstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCloseportalstmt(this); + } +}; + +CloseportalstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCloseportalstmt(this); + } +}; + +CloseportalstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCloseportalstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CloseportalstmtContext = CloseportalstmtContext; + +PostgreSQLParser.prototype.closeportalstmt = function() { + + var localctx = new CloseportalstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 140, PostgreSQLParser.RULE_closeportalstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2597; + this.match(PostgreSQLParser.CLOSE); + this.state = 2600; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.state = 2598; + this.cursor_name(); + break; + case PostgreSQLParser.ALL: + this.state = 2599; + this.match(PostgreSQLParser.ALL); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CopystmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copystmt; + return this; +} + +CopystmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CopystmtContext.prototype.constructor = CopystmtContext; + +CopystmtContext.prototype.COPY = function() { + return this.getToken(PostgreSQLParser.COPY, 0); +}; + +CopystmtContext.prototype.opt_binary = function() { + return this.getTypedRuleContext(Opt_binaryContext,0); +}; + +CopystmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +CopystmtContext.prototype.opt_column_list = function() { + return this.getTypedRuleContext(Opt_column_listContext,0); +}; + +CopystmtContext.prototype.copy_from = function() { + return this.getTypedRuleContext(Copy_fromContext,0); +}; + +CopystmtContext.prototype.opt_program = function() { + return this.getTypedRuleContext(Opt_programContext,0); +}; + +CopystmtContext.prototype.copy_file_name = function() { + return this.getTypedRuleContext(Copy_file_nameContext,0); +}; + +CopystmtContext.prototype.copy_delimiter = function() { + return this.getTypedRuleContext(Copy_delimiterContext,0); +}; + +CopystmtContext.prototype.opt_with = function() { + return this.getTypedRuleContext(Opt_withContext,0); +}; + +CopystmtContext.prototype.copy_options = function() { + return this.getTypedRuleContext(Copy_optionsContext,0); +}; + +CopystmtContext.prototype.where_clause = function() { + return this.getTypedRuleContext(Where_clauseContext,0); +}; + +CopystmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CopystmtContext.prototype.preparablestmt = function() { + return this.getTypedRuleContext(PreparablestmtContext,0); +}; + +CopystmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CopystmtContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +CopystmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopystmt(this); + } +}; + +CopystmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopystmt(this); + } +}; + +CopystmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopystmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CopystmtContext = CopystmtContext; + +PostgreSQLParser.prototype.copystmt = function() { + + var localctx = new CopystmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 142, PostgreSQLParser.RULE_copystmt); + try { + this.state = 2624; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,69,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2602; + this.match(PostgreSQLParser.COPY); + this.state = 2603; + this.opt_binary(); + this.state = 2604; + this.qualified_name(); + this.state = 2605; + this.opt_column_list(); + this.state = 2606; + this.copy_from(); + this.state = 2607; + this.opt_program(); + this.state = 2608; + this.copy_file_name(); + this.state = 2609; + this.copy_delimiter(); + this.state = 2610; + this.opt_with(); + this.state = 2611; + this.copy_options(); + this.state = 2612; + this.where_clause(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 2614; + this.match(PostgreSQLParser.COPY); + this.state = 2615; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2616; + this.preparablestmt(); + this.state = 2617; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 2618; + this.match(PostgreSQLParser.TO); + this.state = 2619; + this.opt_program(); + this.state = 2620; + this.copy_file_name(); + this.state = 2621; + this.opt_with(); + this.state = 2622; + this.copy_options(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_fromContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_from; + return this; +} + +Copy_fromContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_fromContext.prototype.constructor = Copy_fromContext; + +Copy_fromContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Copy_fromContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +Copy_fromContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_from(this); + } +}; + +Copy_fromContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_from(this); + } +}; + +Copy_fromContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_from(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_fromContext = Copy_fromContext; + +PostgreSQLParser.prototype.copy_from = function() { + + var localctx = new Copy_fromContext(this, this._ctx, this.state); + this.enterRule(localctx, 144, PostgreSQLParser.RULE_copy_from); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2626; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FROM || _la===PostgreSQLParser.TO)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_programContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_program; + return this; +} + +Opt_programContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_programContext.prototype.constructor = Opt_programContext; + +Opt_programContext.prototype.PROGRAM = function() { + return this.getToken(PostgreSQLParser.PROGRAM, 0); +}; + +Opt_programContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_program(this); + } +}; + +Opt_programContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_program(this); + } +}; + +Opt_programContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_program(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_programContext = Opt_programContext; + +PostgreSQLParser.prototype.opt_program = function() { + + var localctx = new Opt_programContext(this, this._ctx, this.state); + this.enterRule(localctx, 146, PostgreSQLParser.RULE_opt_program); + try { + this.state = 2630; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.PROGRAM: + this.enterOuterAlt(localctx, 1); + this.state = 2628; + this.match(PostgreSQLParser.PROGRAM); + break; + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_file_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_file_name; + return this; +} + +Copy_file_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_file_nameContext.prototype.constructor = Copy_file_nameContext; + +Copy_file_nameContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Copy_file_nameContext.prototype.STDIN = function() { + return this.getToken(PostgreSQLParser.STDIN, 0); +}; + +Copy_file_nameContext.prototype.STDOUT = function() { + return this.getToken(PostgreSQLParser.STDOUT, 0); +}; + +Copy_file_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_file_name(this); + } +}; + +Copy_file_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_file_name(this); + } +}; + +Copy_file_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_file_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_file_nameContext = Copy_file_nameContext; + +PostgreSQLParser.prototype.copy_file_name = function() { + + var localctx = new Copy_file_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 148, PostgreSQLParser.RULE_copy_file_name); + try { + this.state = 2635; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 2632; + this.sconst(); + break; + case PostgreSQLParser.STDIN: + this.enterOuterAlt(localctx, 2); + this.state = 2633; + this.match(PostgreSQLParser.STDIN); + break; + case PostgreSQLParser.STDOUT: + this.enterOuterAlt(localctx, 3); + this.state = 2634; + this.match(PostgreSQLParser.STDOUT); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_optionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_options; + return this; +} + +Copy_optionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_optionsContext.prototype.constructor = Copy_optionsContext; + +Copy_optionsContext.prototype.copy_opt_list = function() { + return this.getTypedRuleContext(Copy_opt_listContext,0); +}; + +Copy_optionsContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Copy_optionsContext.prototype.copy_generic_opt_list = function() { + return this.getTypedRuleContext(Copy_generic_opt_listContext,0); +}; + +Copy_optionsContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Copy_optionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_options(this); + } +}; + +Copy_optionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_options(this); + } +}; + +Copy_optionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_options(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_optionsContext = Copy_optionsContext; + +PostgreSQLParser.prototype.copy_options = function() { + + var localctx = new Copy_optionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 150, PostgreSQLParser.RULE_copy_options); + try { + this.state = 2642; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,72,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2637; + this.copy_opt_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 2638; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2639; + this.copy_generic_opt_list(); + this.state = 2640; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_opt_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_opt_list; + return this; +} + +Copy_opt_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_opt_listContext.prototype.constructor = Copy_opt_listContext; + +Copy_opt_listContext.prototype.copy_opt_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Copy_opt_itemContext); + } else { + return this.getTypedRuleContext(Copy_opt_itemContext,i); + } +}; + +Copy_opt_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_opt_list(this); + } +}; + +Copy_opt_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_opt_list(this); + } +}; + +Copy_opt_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_opt_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_opt_listContext = Copy_opt_listContext; + +PostgreSQLParser.prototype.copy_opt_list = function() { + + var localctx = new Copy_opt_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 152, PostgreSQLParser.RULE_copy_opt_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2647; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.NULL_P || _la===PostgreSQLParser.BINARY || _la===PostgreSQLParser.FREEZE || ((((_la - 171)) & ~0x1f) == 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.CSV - 171)) | (1 << (PostgreSQLParser.DELIMITER - 171)) | (1 << (PostgreSQLParser.ENCODING - 171)) | (1 << (PostgreSQLParser.ESCAPE - 171)))) !== 0) || _la===PostgreSQLParser.FORCE || _la===PostgreSQLParser.HEADER_P || _la===PostgreSQLParser.QUOTE) { + this.state = 2644; + this.copy_opt_item(); + this.state = 2649; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_opt_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_opt_item; + return this; +} + +Copy_opt_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_opt_itemContext.prototype.constructor = Copy_opt_itemContext; + +Copy_opt_itemContext.prototype.BINARY = function() { + return this.getToken(PostgreSQLParser.BINARY, 0); +}; + +Copy_opt_itemContext.prototype.FREEZE = function() { + return this.getToken(PostgreSQLParser.FREEZE, 0); +}; + +Copy_opt_itemContext.prototype.DELIMITER = function() { + return this.getToken(PostgreSQLParser.DELIMITER, 0); +}; + +Copy_opt_itemContext.prototype.opt_as = function() { + return this.getTypedRuleContext(Opt_asContext,0); +}; + +Copy_opt_itemContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Copy_opt_itemContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +Copy_opt_itemContext.prototype.CSV = function() { + return this.getToken(PostgreSQLParser.CSV, 0); +}; + +Copy_opt_itemContext.prototype.HEADER_P = function() { + return this.getToken(PostgreSQLParser.HEADER_P, 0); +}; + +Copy_opt_itemContext.prototype.QUOTE = function() { + return this.getToken(PostgreSQLParser.QUOTE, 0); +}; + +Copy_opt_itemContext.prototype.ESCAPE = function() { + return this.getToken(PostgreSQLParser.ESCAPE, 0); +}; + +Copy_opt_itemContext.prototype.FORCE = function() { + return this.getToken(PostgreSQLParser.FORCE, 0); +}; + +Copy_opt_itemContext.prototype.columnlist = function() { + return this.getTypedRuleContext(ColumnlistContext,0); +}; + +Copy_opt_itemContext.prototype.STAR = function() { + return this.getToken(PostgreSQLParser.STAR, 0); +}; + +Copy_opt_itemContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +Copy_opt_itemContext.prototype.ENCODING = function() { + return this.getToken(PostgreSQLParser.ENCODING, 0); +}; + +Copy_opt_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_opt_item(this); + } +}; + +Copy_opt_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_opt_item(this); + } +}; + +Copy_opt_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_opt_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_opt_itemContext = Copy_opt_itemContext; + +PostgreSQLParser.prototype.copy_opt_item = function() { + + var localctx = new Copy_opt_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 154, PostgreSQLParser.RULE_copy_opt_item); + try { + this.state = 2685; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,74,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2650; + this.match(PostgreSQLParser.BINARY); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 2651; + this.match(PostgreSQLParser.FREEZE); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 2652; + this.match(PostgreSQLParser.DELIMITER); + this.state = 2653; + this.opt_as(); + this.state = 2654; + this.sconst(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 2656; + this.match(PostgreSQLParser.NULL_P); + this.state = 2657; + this.opt_as(); + this.state = 2658; + this.sconst(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 2660; + this.match(PostgreSQLParser.CSV); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 2661; + this.match(PostgreSQLParser.HEADER_P); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 2662; + this.match(PostgreSQLParser.QUOTE); + this.state = 2663; + this.opt_as(); + this.state = 2664; + this.sconst(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 2666; + this.match(PostgreSQLParser.ESCAPE); + this.state = 2667; + this.opt_as(); + this.state = 2668; + this.sconst(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 2670; + this.match(PostgreSQLParser.FORCE); + this.state = 2671; + this.match(PostgreSQLParser.QUOTE); + this.state = 2672; + this.columnlist(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 2673; + this.match(PostgreSQLParser.FORCE); + this.state = 2674; + this.match(PostgreSQLParser.QUOTE); + this.state = 2675; + this.match(PostgreSQLParser.STAR); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 2676; + this.match(PostgreSQLParser.FORCE); + this.state = 2677; + this.match(PostgreSQLParser.NOT); + this.state = 2678; + this.match(PostgreSQLParser.NULL_P); + this.state = 2679; + this.columnlist(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 2680; + this.match(PostgreSQLParser.FORCE); + this.state = 2681; + this.match(PostgreSQLParser.NULL_P); + this.state = 2682; + this.columnlist(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 2683; + this.match(PostgreSQLParser.ENCODING); + this.state = 2684; + this.sconst(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_binaryContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_binary; + return this; +} + +Opt_binaryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_binaryContext.prototype.constructor = Opt_binaryContext; + +Opt_binaryContext.prototype.BINARY = function() { + return this.getToken(PostgreSQLParser.BINARY, 0); +}; + +Opt_binaryContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_binary(this); + } +}; + +Opt_binaryContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_binary(this); + } +}; + +Opt_binaryContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_binary(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_binaryContext = Opt_binaryContext; + +PostgreSQLParser.prototype.opt_binary = function() { + + var localctx = new Opt_binaryContext(this, this._ctx, this.state); + this.enterRule(localctx, 156, PostgreSQLParser.RULE_opt_binary); + try { + this.state = 2689; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.BINARY: + this.enterOuterAlt(localctx, 1); + this.state = 2687; + this.match(PostgreSQLParser.BINARY); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_delimiterContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_delimiter; + return this; +} + +Copy_delimiterContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_delimiterContext.prototype.constructor = Copy_delimiterContext; + +Copy_delimiterContext.prototype.opt_using = function() { + return this.getTypedRuleContext(Opt_usingContext,0); +}; + +Copy_delimiterContext.prototype.DELIMITERS = function() { + return this.getToken(PostgreSQLParser.DELIMITERS, 0); +}; + +Copy_delimiterContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Copy_delimiterContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_delimiter(this); + } +}; + +Copy_delimiterContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_delimiter(this); + } +}; + +Copy_delimiterContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_delimiter(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_delimiterContext = Copy_delimiterContext; + +PostgreSQLParser.prototype.copy_delimiter = function() { + + var localctx = new Copy_delimiterContext(this, this._ctx, this.state); + this.enterRule(localctx, 158, PostgreSQLParser.RULE_copy_delimiter); + try { + this.state = 2696; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + case PostgreSQLParser.DELIMITERS: + this.enterOuterAlt(localctx, 1); + this.state = 2691; + this.opt_using(); + this.state = 2692; + this.match(PostgreSQLParser.DELIMITERS); + this.state = 2693; + this.sconst(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.CSV: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_usingContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_using; + return this; +} + +Opt_usingContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_usingContext.prototype.constructor = Opt_usingContext; + +Opt_usingContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Opt_usingContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_using(this); + } +}; + +Opt_usingContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_using(this); + } +}; + +Opt_usingContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_using(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_usingContext = Opt_usingContext; + +PostgreSQLParser.prototype.opt_using = function() { + + var localctx = new Opt_usingContext(this, this._ctx, this.state); + this.enterRule(localctx, 160, PostgreSQLParser.RULE_opt_using); + try { + this.state = 2700; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + this.state = 2698; + this.match(PostgreSQLParser.USING); + break; + case PostgreSQLParser.DELIMITERS: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_generic_opt_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_generic_opt_list; + return this; +} + +Copy_generic_opt_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_generic_opt_listContext.prototype.constructor = Copy_generic_opt_listContext; + +Copy_generic_opt_listContext.prototype.copy_generic_opt_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Copy_generic_opt_elemContext); + } else { + return this.getTypedRuleContext(Copy_generic_opt_elemContext,i); + } +}; + +Copy_generic_opt_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Copy_generic_opt_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_generic_opt_list(this); + } +}; + +Copy_generic_opt_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_generic_opt_list(this); + } +}; + +Copy_generic_opt_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_generic_opt_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_generic_opt_listContext = Copy_generic_opt_listContext; + +PostgreSQLParser.prototype.copy_generic_opt_list = function() { + + var localctx = new Copy_generic_opt_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 162, PostgreSQLParser.RULE_copy_generic_opt_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2702; + this.copy_generic_opt_elem(); + this.state = 2707; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 2703; + this.match(PostgreSQLParser.COMMA); + this.state = 2704; + this.copy_generic_opt_elem(); + this.state = 2709; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_generic_opt_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_generic_opt_elem; + return this; +} + +Copy_generic_opt_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_generic_opt_elemContext.prototype.constructor = Copy_generic_opt_elemContext; + +Copy_generic_opt_elemContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +Copy_generic_opt_elemContext.prototype.copy_generic_opt_arg = function() { + return this.getTypedRuleContext(Copy_generic_opt_argContext,0); +}; + +Copy_generic_opt_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_generic_opt_elem(this); + } +}; + +Copy_generic_opt_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_generic_opt_elem(this); + } +}; + +Copy_generic_opt_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_generic_opt_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_generic_opt_elemContext = Copy_generic_opt_elemContext; + +PostgreSQLParser.prototype.copy_generic_opt_elem = function() { + + var localctx = new Copy_generic_opt_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 164, PostgreSQLParser.RULE_copy_generic_opt_elem); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2710; + this.collabel(); + this.state = 2711; + this.copy_generic_opt_arg(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_generic_opt_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_generic_opt_arg; + return this; +} + +Copy_generic_opt_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_generic_opt_argContext.prototype.constructor = Copy_generic_opt_argContext; + +Copy_generic_opt_argContext.prototype.opt_boolean_or_string = function() { + return this.getTypedRuleContext(Opt_boolean_or_stringContext,0); +}; + +Copy_generic_opt_argContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +Copy_generic_opt_argContext.prototype.STAR = function() { + return this.getToken(PostgreSQLParser.STAR, 0); +}; + +Copy_generic_opt_argContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Copy_generic_opt_argContext.prototype.copy_generic_opt_arg_list = function() { + return this.getTypedRuleContext(Copy_generic_opt_arg_listContext,0); +}; + +Copy_generic_opt_argContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Copy_generic_opt_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_generic_opt_arg(this); + } +}; + +Copy_generic_opt_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_generic_opt_arg(this); + } +}; + +Copy_generic_opt_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_generic_opt_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_generic_opt_argContext = Copy_generic_opt_argContext; + +PostgreSQLParser.prototype.copy_generic_opt_arg = function() { + + var localctx = new Copy_generic_opt_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 166, PostgreSQLParser.RULE_copy_generic_opt_arg); + try { + this.state = 2721; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.ON: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 2713; + this.opt_boolean_or_string(); + break; + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + this.enterOuterAlt(localctx, 2); + this.state = 2714; + this.numericonly(); + break; + case PostgreSQLParser.STAR: + this.enterOuterAlt(localctx, 3); + this.state = 2715; + this.match(PostgreSQLParser.STAR); + break; + case PostgreSQLParser.OPEN_PAREN: + this.enterOuterAlt(localctx, 4); + this.state = 2716; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2717; + this.copy_generic_opt_arg_list(); + this.state = 2718; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + this.enterOuterAlt(localctx, 5); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_generic_opt_arg_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_generic_opt_arg_list; + return this; +} + +Copy_generic_opt_arg_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_generic_opt_arg_listContext.prototype.constructor = Copy_generic_opt_arg_listContext; + +Copy_generic_opt_arg_listContext.prototype.copy_generic_opt_arg_list_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Copy_generic_opt_arg_list_itemContext); + } else { + return this.getTypedRuleContext(Copy_generic_opt_arg_list_itemContext,i); + } +}; + +Copy_generic_opt_arg_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Copy_generic_opt_arg_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_generic_opt_arg_list(this); + } +}; + +Copy_generic_opt_arg_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_generic_opt_arg_list(this); + } +}; + +Copy_generic_opt_arg_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_generic_opt_arg_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_generic_opt_arg_listContext = Copy_generic_opt_arg_listContext; + +PostgreSQLParser.prototype.copy_generic_opt_arg_list = function() { + + var localctx = new Copy_generic_opt_arg_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 168, PostgreSQLParser.RULE_copy_generic_opt_arg_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2723; + this.copy_generic_opt_arg_list_item(); + this.state = 2728; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 2724; + this.match(PostgreSQLParser.COMMA); + this.state = 2725; + this.copy_generic_opt_arg_list_item(); + this.state = 2730; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Copy_generic_opt_arg_list_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_copy_generic_opt_arg_list_item; + return this; +} + +Copy_generic_opt_arg_list_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Copy_generic_opt_arg_list_itemContext.prototype.constructor = Copy_generic_opt_arg_list_itemContext; + +Copy_generic_opt_arg_list_itemContext.prototype.opt_boolean_or_string = function() { + return this.getTypedRuleContext(Opt_boolean_or_stringContext,0); +}; + +Copy_generic_opt_arg_list_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCopy_generic_opt_arg_list_item(this); + } +}; + +Copy_generic_opt_arg_list_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCopy_generic_opt_arg_list_item(this); + } +}; + +Copy_generic_opt_arg_list_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCopy_generic_opt_arg_list_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Copy_generic_opt_arg_list_itemContext = Copy_generic_opt_arg_list_itemContext; + +PostgreSQLParser.prototype.copy_generic_opt_arg_list_item = function() { + + var localctx = new Copy_generic_opt_arg_list_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 170, PostgreSQLParser.RULE_copy_generic_opt_arg_list_item); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2731; + this.opt_boolean_or_string(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createstmt; + return this; +} + +CreatestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatestmtContext.prototype.constructor = CreatestmtContext; + +CreatestmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatestmtContext.prototype.opttemp = function() { + return this.getTypedRuleContext(OpttempContext,0); +}; + +CreatestmtContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +CreatestmtContext.prototype.qualified_name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Qualified_nameContext); + } else { + return this.getTypedRuleContext(Qualified_nameContext,i); + } +}; + +CreatestmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CreatestmtContext.prototype.opttableelementlist = function() { + return this.getTypedRuleContext(OpttableelementlistContext,0); +}; + +CreatestmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CreatestmtContext.prototype.optinherit = function() { + return this.getTypedRuleContext(OptinheritContext,0); +}; + +CreatestmtContext.prototype.optpartitionspec = function() { + return this.getTypedRuleContext(OptpartitionspecContext,0); +}; + +CreatestmtContext.prototype.table_access_method_clause = function() { + return this.getTypedRuleContext(Table_access_method_clauseContext,0); +}; + +CreatestmtContext.prototype.optwith = function() { + return this.getTypedRuleContext(OptwithContext,0); +}; + +CreatestmtContext.prototype.oncommitoption = function() { + return this.getTypedRuleContext(OncommitoptionContext,0); +}; + +CreatestmtContext.prototype.opttablespace = function() { + return this.getTypedRuleContext(OpttablespaceContext,0); +}; + +CreatestmtContext.prototype.OF = function() { + return this.getToken(PostgreSQLParser.OF, 0); +}; + +CreatestmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +CreatestmtContext.prototype.opttypedtableelementlist = function() { + return this.getTypedRuleContext(OpttypedtableelementlistContext,0); +}; + +CreatestmtContext.prototype.PARTITION = function() { + return this.getToken(PostgreSQLParser.PARTITION, 0); +}; + +CreatestmtContext.prototype.partitionboundspec = function() { + return this.getTypedRuleContext(PartitionboundspecContext,0); +}; + +CreatestmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +CreatestmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +CreatestmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +CreatestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatestmt(this); + } +}; + +CreatestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatestmt(this); + } +}; + +CreatestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatestmtContext = CreatestmtContext; + +PostgreSQLParser.prototype.createstmt = function() { + + var localctx = new CreatestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 172, PostgreSQLParser.RULE_createstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2733; + this.match(PostgreSQLParser.CREATE); + this.state = 2734; + this.opttemp(); + this.state = 2735; + this.match(PostgreSQLParser.TABLE); + this.state = 2739; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,81,this._ctx); + if(la_===1) { + this.state = 2736; + this.match(PostgreSQLParser.IF_P); + this.state = 2737; + this.match(PostgreSQLParser.NOT); + this.state = 2738; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 2741; + this.qualified_name(); + this.state = 2772; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + this.state = 2742; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2743; + this.opttableelementlist(); + this.state = 2744; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 2745; + this.optinherit(); + this.state = 2746; + this.optpartitionspec(); + this.state = 2747; + this.table_access_method_clause(); + this.state = 2748; + this.optwith(); + this.state = 2749; + this.oncommitoption(); + this.state = 2750; + this.opttablespace(); + break; + case PostgreSQLParser.OF: + this.state = 2752; + this.match(PostgreSQLParser.OF); + this.state = 2753; + this.any_name(); + this.state = 2754; + this.opttypedtableelementlist(); + this.state = 2755; + this.optpartitionspec(); + this.state = 2756; + this.table_access_method_clause(); + this.state = 2757; + this.optwith(); + this.state = 2758; + this.oncommitoption(); + this.state = 2759; + this.opttablespace(); + break; + case PostgreSQLParser.PARTITION: + this.state = 2761; + this.match(PostgreSQLParser.PARTITION); + this.state = 2762; + this.match(PostgreSQLParser.OF); + this.state = 2763; + this.qualified_name(); + this.state = 2764; + this.opttypedtableelementlist(); + this.state = 2765; + this.partitionboundspec(); + this.state = 2766; + this.optpartitionspec(); + this.state = 2767; + this.table_access_method_clause(); + this.state = 2768; + this.optwith(); + this.state = 2769; + this.oncommitoption(); + this.state = 2770; + this.opttablespace(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OpttempContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opttemp; + return this; +} + +OpttempContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OpttempContext.prototype.constructor = OpttempContext; + +OpttempContext.prototype.TEMPORARY = function() { + return this.getToken(PostgreSQLParser.TEMPORARY, 0); +}; + +OpttempContext.prototype.TEMP = function() { + return this.getToken(PostgreSQLParser.TEMP, 0); +}; + +OpttempContext.prototype.LOCAL = function() { + return this.getToken(PostgreSQLParser.LOCAL, 0); +}; + +OpttempContext.prototype.GLOBAL = function() { + return this.getToken(PostgreSQLParser.GLOBAL, 0); +}; + +OpttempContext.prototype.UNLOGGED = function() { + return this.getToken(PostgreSQLParser.UNLOGGED, 0); +}; + +OpttempContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpttemp(this); + } +}; + +OpttempContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpttemp(this); + } +}; + +OpttempContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpttemp(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OpttempContext = OpttempContext; + +PostgreSQLParser.prototype.opttemp = function() { + + var localctx = new OpttempContext(this, this._ctx, this.state); + this.enterRule(localctx, 174, PostgreSQLParser.RULE_opttemp); + var _la = 0; // Token type + try { + this.state = 2782; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.TEMPORARY: + this.enterOuterAlt(localctx, 1); + this.state = 2774; + this.match(PostgreSQLParser.TEMPORARY); + break; + case PostgreSQLParser.TEMP: + this.enterOuterAlt(localctx, 2); + this.state = 2775; + this.match(PostgreSQLParser.TEMP); + break; + case PostgreSQLParser.LOCAL: + this.enterOuterAlt(localctx, 3); + this.state = 2776; + this.match(PostgreSQLParser.LOCAL); + this.state = 2777; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.TEMP || _la===PostgreSQLParser.TEMPORARY)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + case PostgreSQLParser.GLOBAL: + this.enterOuterAlt(localctx, 4); + this.state = 2778; + this.match(PostgreSQLParser.GLOBAL); + this.state = 2779; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.TEMP || _la===PostgreSQLParser.TEMPORARY)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + case PostgreSQLParser.UNLOGGED: + this.enterOuterAlt(localctx, 5); + this.state = 2780; + this.match(PostgreSQLParser.UNLOGGED); + break; + case PostgreSQLParser.TABLE: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.VIEW: + this.enterOuterAlt(localctx, 6); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OpttableelementlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opttableelementlist; + return this; +} + +OpttableelementlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OpttableelementlistContext.prototype.constructor = OpttableelementlistContext; + +OpttableelementlistContext.prototype.tableelementlist = function() { + return this.getTypedRuleContext(TableelementlistContext,0); +}; + +OpttableelementlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpttableelementlist(this); + } +}; + +OpttableelementlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpttableelementlist(this); + } +}; + +OpttableelementlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpttableelementlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OpttableelementlistContext = OpttableelementlistContext; + +PostgreSQLParser.prototype.opttableelementlist = function() { + + var localctx = new OpttableelementlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 176, PostgreSQLParser.RULE_opttableelementlist); + try { + this.state = 2786; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CHECK: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOREIGN: + case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.IS: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 2784; + this.tableelementlist(); + break; + case PostgreSQLParser.CLOSE_PAREN: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OpttypedtableelementlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opttypedtableelementlist; + return this; +} + +OpttypedtableelementlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OpttypedtableelementlistContext.prototype.constructor = OpttypedtableelementlistContext; + +OpttypedtableelementlistContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +OpttypedtableelementlistContext.prototype.typedtableelementlist = function() { + return this.getTypedRuleContext(TypedtableelementlistContext,0); +}; + +OpttypedtableelementlistContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +OpttypedtableelementlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpttypedtableelementlist(this); + } +}; + +OpttypedtableelementlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpttypedtableelementlist(this); + } +}; + +OpttypedtableelementlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpttypedtableelementlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OpttypedtableelementlistContext = OpttypedtableelementlistContext; + +PostgreSQLParser.prototype.opttypedtableelementlist = function() { + + var localctx = new OpttypedtableelementlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 178, PostgreSQLParser.RULE_opttypedtableelementlist); + try { + this.state = 2793; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,85,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2788; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2789; + this.typedtableelementlist(); + this.state = 2790; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TableelementlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_tableelementlist; + return this; +} + +TableelementlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TableelementlistContext.prototype.constructor = TableelementlistContext; + +TableelementlistContext.prototype.tableelement = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TableelementContext); + } else { + return this.getTypedRuleContext(TableelementContext,i); + } +}; + +TableelementlistContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +TableelementlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTableelementlist(this); + } +}; + +TableelementlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTableelementlist(this); + } +}; + +TableelementlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTableelementlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TableelementlistContext = TableelementlistContext; + +PostgreSQLParser.prototype.tableelementlist = function() { + + var localctx = new TableelementlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 180, PostgreSQLParser.RULE_tableelementlist); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2795; + this.tableelement(); + this.state = 2800; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 2796; + this.match(PostgreSQLParser.COMMA); + this.state = 2797; + this.tableelement(); + this.state = 2802; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TypedtableelementlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_typedtableelementlist; + return this; +} + +TypedtableelementlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TypedtableelementlistContext.prototype.constructor = TypedtableelementlistContext; + +TypedtableelementlistContext.prototype.typedtableelement = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TypedtableelementContext); + } else { + return this.getTypedRuleContext(TypedtableelementContext,i); + } +}; + +TypedtableelementlistContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +TypedtableelementlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTypedtableelementlist(this); + } +}; + +TypedtableelementlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTypedtableelementlist(this); + } +}; + +TypedtableelementlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTypedtableelementlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TypedtableelementlistContext = TypedtableelementlistContext; + +PostgreSQLParser.prototype.typedtableelementlist = function() { + + var localctx = new TypedtableelementlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 182, PostgreSQLParser.RULE_typedtableelementlist); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2803; + this.typedtableelement(); + this.state = 2808; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 2804; + this.match(PostgreSQLParser.COMMA); + this.state = 2805; + this.typedtableelement(); + this.state = 2810; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TableelementContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_tableelement; + return this; +} + +TableelementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TableelementContext.prototype.constructor = TableelementContext; + +TableelementContext.prototype.columnDef = function() { + return this.getTypedRuleContext(ColumnDefContext,0); +}; + +TableelementContext.prototype.tablelikeclause = function() { + return this.getTypedRuleContext(TablelikeclauseContext,0); +}; + +TableelementContext.prototype.tableconstraint = function() { + return this.getTypedRuleContext(TableconstraintContext,0); +}; + +TableelementContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTableelement(this); + } +}; + +TableelementContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTableelement(this); + } +}; + +TableelementContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTableelement(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TableelementContext = TableelementContext; + +PostgreSQLParser.prototype.tableelement = function() { + + var localctx = new TableelementContext(this, this._ctx, this.state); + this.enterRule(localctx, 184, PostgreSQLParser.RULE_tableelement); + try { + this.state = 2814; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,88,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2811; + this.columnDef(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 2812; + this.tablelikeclause(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 2813; + this.tableconstraint(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TypedtableelementContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_typedtableelement; + return this; +} + +TypedtableelementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TypedtableelementContext.prototype.constructor = TypedtableelementContext; + +TypedtableelementContext.prototype.columnOptions = function() { + return this.getTypedRuleContext(ColumnOptionsContext,0); +}; + +TypedtableelementContext.prototype.tableconstraint = function() { + return this.getTypedRuleContext(TableconstraintContext,0); +}; + +TypedtableelementContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTypedtableelement(this); + } +}; + +TypedtableelementContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTypedtableelement(this); + } +}; + +TypedtableelementContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTypedtableelement(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TypedtableelementContext = TypedtableelementContext; + +PostgreSQLParser.prototype.typedtableelement = function() { + + var localctx = new TypedtableelementContext(this, this._ctx, this.state); + this.enterRule(localctx, 186, PostgreSQLParser.RULE_typedtableelement); + try { + this.state = 2818; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,89,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2816; + this.columnOptions(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 2817; + this.tableconstraint(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ColumnDefContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_columnDef; + return this; +} + +ColumnDefContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ColumnDefContext.prototype.constructor = ColumnDefContext; + +ColumnDefContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +ColumnDefContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +ColumnDefContext.prototype.create_generic_options = function() { + return this.getTypedRuleContext(Create_generic_optionsContext,0); +}; + +ColumnDefContext.prototype.colquallist = function() { + return this.getTypedRuleContext(ColquallistContext,0); +}; + +ColumnDefContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterColumnDef(this); + } +}; + +ColumnDefContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitColumnDef(this); + } +}; + +ColumnDefContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitColumnDef(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ColumnDefContext = ColumnDefContext; + +PostgreSQLParser.prototype.columnDef = function() { + + var localctx = new ColumnDefContext(this, this._ctx, this.state); + this.enterRule(localctx, 188, PostgreSQLParser.RULE_columnDef); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2820; + this.colid(); + this.state = 2821; + this.typename(); + this.state = 2822; + this.create_generic_options(); + this.state = 2823; + this.colquallist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ColumnOptionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_columnOptions; + return this; +} + +ColumnOptionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ColumnOptionsContext.prototype.constructor = ColumnOptionsContext; + +ColumnOptionsContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +ColumnOptionsContext.prototype.colquallist = function() { + return this.getTypedRuleContext(ColquallistContext,0); +}; + +ColumnOptionsContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +ColumnOptionsContext.prototype.OPTIONS = function() { + return this.getToken(PostgreSQLParser.OPTIONS, 0); +}; + +ColumnOptionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterColumnOptions(this); + } +}; + +ColumnOptionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitColumnOptions(this); + } +}; + +ColumnOptionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitColumnOptions(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ColumnOptionsContext = ColumnOptionsContext; + +PostgreSQLParser.prototype.columnOptions = function() { + + var localctx = new ColumnOptionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 190, PostgreSQLParser.RULE_columnOptions); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2825; + this.colid(); + this.state = 2828; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.WITH) { + this.state = 2826; + this.match(PostgreSQLParser.WITH); + this.state = 2827; + this.match(PostgreSQLParser.OPTIONS); + } + + this.state = 2830; + this.colquallist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ColquallistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_colquallist; + return this; +} + +ColquallistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ColquallistContext.prototype.constructor = ColquallistContext; + +ColquallistContext.prototype.colconstraint = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(ColconstraintContext); + } else { + return this.getTypedRuleContext(ColconstraintContext,i); + } +}; + +ColquallistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterColquallist(this); + } +}; + +ColquallistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitColquallist(this); + } +}; + +ColquallistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitColquallist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ColquallistContext = ColquallistContext; + +PostgreSQLParser.prototype.colquallist = function() { + + var localctx = new ColquallistContext(this, this._ctx, this.state); + this.enterRule(localctx, 192, PostgreSQLParser.RULE_colquallist); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2835; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(((((_la - 42)) & ~0x1f) == 0 && ((1 << (_la - 42)) & ((1 << (PostgreSQLParser.CHECK - 42)) | (1 << (PostgreSQLParser.COLLATE - 42)) | (1 << (PostgreSQLParser.CONSTRAINT - 42)) | (1 << (PostgreSQLParser.DEFAULT - 42)) | (1 << (PostgreSQLParser.DEFERRABLE - 42)) | (1 << (PostgreSQLParser.INITIALLY - 42)))) !== 0) || ((((_la - 77)) & ~0x1f) == 0 && ((1 << (_la - 77)) & ((1 << (PostgreSQLParser.NOT - 77)) | (1 << (PostgreSQLParser.NULL_P - 77)) | (1 << (PostgreSQLParser.PRIMARY - 77)) | (1 << (PostgreSQLParser.REFERENCES - 77)) | (1 << (PostgreSQLParser.UNIQUE - 77)))) !== 0) || _la===PostgreSQLParser.GENERATED) { + this.state = 2832; + this.colconstraint(); + this.state = 2837; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ColconstraintContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_colconstraint; + return this; +} + +ColconstraintContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ColconstraintContext.prototype.constructor = ColconstraintContext; + +ColconstraintContext.prototype.CONSTRAINT = function() { + return this.getToken(PostgreSQLParser.CONSTRAINT, 0); +}; + +ColconstraintContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +ColconstraintContext.prototype.colconstraintelem = function() { + return this.getTypedRuleContext(ColconstraintelemContext,0); +}; + +ColconstraintContext.prototype.constraintattr = function() { + return this.getTypedRuleContext(ConstraintattrContext,0); +}; + +ColconstraintContext.prototype.COLLATE = function() { + return this.getToken(PostgreSQLParser.COLLATE, 0); +}; + +ColconstraintContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +ColconstraintContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterColconstraint(this); + } +}; + +ColconstraintContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitColconstraint(this); + } +}; + +ColconstraintContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitColconstraint(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ColconstraintContext = ColconstraintContext; + +PostgreSQLParser.prototype.colconstraint = function() { + + var localctx = new ColconstraintContext(this, this._ctx, this.state); + this.enterRule(localctx, 194, PostgreSQLParser.RULE_colconstraint); + try { + this.state = 2846; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,92,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2838; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 2839; + this.name(); + this.state = 2840; + this.colconstraintelem(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 2842; + this.colconstraintelem(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 2843; + this.constraintattr(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 2844; + this.match(PostgreSQLParser.COLLATE); + this.state = 2845; + this.any_name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ColconstraintelemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_colconstraintelem; + return this; +} + +ColconstraintelemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ColconstraintelemContext.prototype.constructor = ColconstraintelemContext; + +ColconstraintelemContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +ColconstraintelemContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +ColconstraintelemContext.prototype.UNIQUE = function() { + return this.getToken(PostgreSQLParser.UNIQUE, 0); +}; + +ColconstraintelemContext.prototype.opt_definition = function() { + return this.getTypedRuleContext(Opt_definitionContext,0); +}; + +ColconstraintelemContext.prototype.optconstablespace = function() { + return this.getTypedRuleContext(OptconstablespaceContext,0); +}; + +ColconstraintelemContext.prototype.PRIMARY = function() { + return this.getToken(PostgreSQLParser.PRIMARY, 0); +}; + +ColconstraintelemContext.prototype.KEY = function() { + return this.getToken(PostgreSQLParser.KEY, 0); +}; + +ColconstraintelemContext.prototype.CHECK = function() { + return this.getToken(PostgreSQLParser.CHECK, 0); +}; + +ColconstraintelemContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +ColconstraintelemContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +ColconstraintelemContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +ColconstraintelemContext.prototype.opt_no_inherit = function() { + return this.getTypedRuleContext(Opt_no_inheritContext,0); +}; + +ColconstraintelemContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +ColconstraintelemContext.prototype.b_expr = function() { + return this.getTypedRuleContext(B_exprContext,0); +}; + +ColconstraintelemContext.prototype.GENERATED = function() { + return this.getToken(PostgreSQLParser.GENERATED, 0); +}; + +ColconstraintelemContext.prototype.generated_when = function() { + return this.getTypedRuleContext(Generated_whenContext,0); +}; + +ColconstraintelemContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +ColconstraintelemContext.prototype.IDENTITY_P = function() { + return this.getToken(PostgreSQLParser.IDENTITY_P, 0); +}; + +ColconstraintelemContext.prototype.optparenthesizedseqoptlist = function() { + return this.getTypedRuleContext(OptparenthesizedseqoptlistContext,0); +}; + +ColconstraintelemContext.prototype.STORED = function() { + return this.getToken(PostgreSQLParser.STORED, 0); +}; + +ColconstraintelemContext.prototype.REFERENCES = function() { + return this.getToken(PostgreSQLParser.REFERENCES, 0); +}; + +ColconstraintelemContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +ColconstraintelemContext.prototype.opt_column_list = function() { + return this.getTypedRuleContext(Opt_column_listContext,0); +}; + +ColconstraintelemContext.prototype.key_match = function() { + return this.getTypedRuleContext(Key_matchContext,0); +}; + +ColconstraintelemContext.prototype.key_actions = function() { + return this.getTypedRuleContext(Key_actionsContext,0); +}; + +ColconstraintelemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterColconstraintelem(this); + } +}; + +ColconstraintelemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitColconstraintelem(this); + } +}; + +ColconstraintelemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitColconstraintelem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ColconstraintelemContext = ColconstraintelemContext; + +PostgreSQLParser.prototype.colconstraintelem = function() { + + var localctx = new ColconstraintelemContext(this, this._ctx, this.state); + this.enterRule(localctx, 196, PostgreSQLParser.RULE_colconstraintelem); + try { + this.state = 2886; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NOT: + this.enterOuterAlt(localctx, 1); + this.state = 2848; + this.match(PostgreSQLParser.NOT); + this.state = 2849; + this.match(PostgreSQLParser.NULL_P); + break; + case PostgreSQLParser.NULL_P: + this.enterOuterAlt(localctx, 2); + this.state = 2850; + this.match(PostgreSQLParser.NULL_P); + break; + case PostgreSQLParser.UNIQUE: + this.enterOuterAlt(localctx, 3); + this.state = 2851; + this.match(PostgreSQLParser.UNIQUE); + this.state = 2852; + this.opt_definition(); + this.state = 2853; + this.optconstablespace(); + break; + case PostgreSQLParser.PRIMARY: + this.enterOuterAlt(localctx, 4); + this.state = 2855; + this.match(PostgreSQLParser.PRIMARY); + this.state = 2856; + this.match(PostgreSQLParser.KEY); + this.state = 2857; + this.opt_definition(); + this.state = 2858; + this.optconstablespace(); + break; + case PostgreSQLParser.CHECK: + this.enterOuterAlt(localctx, 5); + this.state = 2860; + this.match(PostgreSQLParser.CHECK); + this.state = 2861; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2862; + this.a_expr(); + this.state = 2863; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 2864; + this.opt_no_inherit(); + break; + case PostgreSQLParser.DEFAULT: + this.enterOuterAlt(localctx, 6); + this.state = 2866; + this.match(PostgreSQLParser.DEFAULT); + this.state = 2867; + this.b_expr(0); + break; + case PostgreSQLParser.GENERATED: + this.enterOuterAlt(localctx, 7); + this.state = 2868; + this.match(PostgreSQLParser.GENERATED); + this.state = 2869; + this.generated_when(); + this.state = 2870; + this.match(PostgreSQLParser.AS); + this.state = 2878; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.IDENTITY_P: + this.state = 2871; + this.match(PostgreSQLParser.IDENTITY_P); + this.state = 2872; + this.optparenthesizedseqoptlist(); + break; + case PostgreSQLParser.OPEN_PAREN: + this.state = 2873; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2874; + this.a_expr(); + this.state = 2875; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 2876; + this.match(PostgreSQLParser.STORED); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + case PostgreSQLParser.REFERENCES: + this.enterOuterAlt(localctx, 8); + this.state = 2880; + this.match(PostgreSQLParser.REFERENCES); + this.state = 2881; + this.qualified_name(); + this.state = 2882; + this.opt_column_list(); + this.state = 2883; + this.key_match(); + this.state = 2884; + this.key_actions(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Generated_whenContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_generated_when; + return this; +} + +Generated_whenContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Generated_whenContext.prototype.constructor = Generated_whenContext; + +Generated_whenContext.prototype.ALWAYS = function() { + return this.getToken(PostgreSQLParser.ALWAYS, 0); +}; + +Generated_whenContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Generated_whenContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Generated_whenContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGenerated_when(this); + } +}; + +Generated_whenContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGenerated_when(this); + } +}; + +Generated_whenContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGenerated_when(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Generated_whenContext = Generated_whenContext; + +PostgreSQLParser.prototype.generated_when = function() { + + var localctx = new Generated_whenContext(this, this._ctx, this.state); + this.enterRule(localctx, 198, PostgreSQLParser.RULE_generated_when); + try { + this.state = 2891; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ALWAYS: + this.enterOuterAlt(localctx, 1); + this.state = 2888; + this.match(PostgreSQLParser.ALWAYS); + break; + case PostgreSQLParser.BY: + this.enterOuterAlt(localctx, 2); + this.state = 2889; + this.match(PostgreSQLParser.BY); + this.state = 2890; + this.match(PostgreSQLParser.DEFAULT); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ConstraintattrContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constraintattr; + return this; +} + +ConstraintattrContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ConstraintattrContext.prototype.constructor = ConstraintattrContext; + +ConstraintattrContext.prototype.DEFERRABLE = function() { + return this.getToken(PostgreSQLParser.DEFERRABLE, 0); +}; + +ConstraintattrContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +ConstraintattrContext.prototype.INITIALLY = function() { + return this.getToken(PostgreSQLParser.INITIALLY, 0); +}; + +ConstraintattrContext.prototype.DEFERRED = function() { + return this.getToken(PostgreSQLParser.DEFERRED, 0); +}; + +ConstraintattrContext.prototype.IMMEDIATE = function() { + return this.getToken(PostgreSQLParser.IMMEDIATE, 0); +}; + +ConstraintattrContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstraintattr(this); + } +}; + +ConstraintattrContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstraintattr(this); + } +}; + +ConstraintattrContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstraintattr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ConstraintattrContext = ConstraintattrContext; + +PostgreSQLParser.prototype.constraintattr = function() { + + var localctx = new ConstraintattrContext(this, this._ctx, this.state); + this.enterRule(localctx, 200, PostgreSQLParser.RULE_constraintattr); + var _la = 0; // Token type + try { + this.state = 2898; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.DEFERRABLE: + this.enterOuterAlt(localctx, 1); + this.state = 2893; + this.match(PostgreSQLParser.DEFERRABLE); + break; + case PostgreSQLParser.NOT: + this.enterOuterAlt(localctx, 2); + this.state = 2894; + this.match(PostgreSQLParser.NOT); + this.state = 2895; + this.match(PostgreSQLParser.DEFERRABLE); + break; + case PostgreSQLParser.INITIALLY: + this.enterOuterAlt(localctx, 3); + this.state = 2896; + this.match(PostgreSQLParser.INITIALLY); + this.state = 2897; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.DEFERRED || _la===PostgreSQLParser.IMMEDIATE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TablelikeclauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_tablelikeclause; + return this; +} + +TablelikeclauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TablelikeclauseContext.prototype.constructor = TablelikeclauseContext; + +TablelikeclauseContext.prototype.LIKE = function() { + return this.getToken(PostgreSQLParser.LIKE, 0); +}; + +TablelikeclauseContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +TablelikeclauseContext.prototype.tablelikeoptionlist = function() { + return this.getTypedRuleContext(TablelikeoptionlistContext,0); +}; + +TablelikeclauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTablelikeclause(this); + } +}; + +TablelikeclauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTablelikeclause(this); + } +}; + +TablelikeclauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTablelikeclause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TablelikeclauseContext = TablelikeclauseContext; + +PostgreSQLParser.prototype.tablelikeclause = function() { + + var localctx = new TablelikeclauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 202, PostgreSQLParser.RULE_tablelikeclause); + try { + this.enterOuterAlt(localctx, 1); + this.state = 2900; + this.match(PostgreSQLParser.LIKE); + this.state = 2901; + this.qualified_name(); + this.state = 2902; + this.tablelikeoptionlist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TablelikeoptionlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_tablelikeoptionlist; + return this; +} + +TablelikeoptionlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TablelikeoptionlistContext.prototype.constructor = TablelikeoptionlistContext; + +TablelikeoptionlistContext.prototype.tablelikeoption = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TablelikeoptionContext); + } else { + return this.getTypedRuleContext(TablelikeoptionContext,i); + } +}; + +TablelikeoptionlistContext.prototype.INCLUDING = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.INCLUDING); + } else { + return this.getToken(PostgreSQLParser.INCLUDING, i); + } +}; + + +TablelikeoptionlistContext.prototype.EXCLUDING = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.EXCLUDING); + } else { + return this.getToken(PostgreSQLParser.EXCLUDING, i); + } +}; + + +TablelikeoptionlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTablelikeoptionlist(this); + } +}; + +TablelikeoptionlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTablelikeoptionlist(this); + } +}; + +TablelikeoptionlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTablelikeoptionlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TablelikeoptionlistContext = TablelikeoptionlistContext; + +PostgreSQLParser.prototype.tablelikeoptionlist = function() { + + var localctx = new TablelikeoptionlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 204, PostgreSQLParser.RULE_tablelikeoptionlist); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2908; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.EXCLUDING || _la===PostgreSQLParser.INCLUDING) { + this.state = 2904; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.EXCLUDING || _la===PostgreSQLParser.INCLUDING)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 2905; + this.tablelikeoption(); + this.state = 2910; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TablelikeoptionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_tablelikeoption; + return this; +} + +TablelikeoptionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TablelikeoptionContext.prototype.constructor = TablelikeoptionContext; + +TablelikeoptionContext.prototype.COMMENTS = function() { + return this.getToken(PostgreSQLParser.COMMENTS, 0); +}; + +TablelikeoptionContext.prototype.CONSTRAINTS = function() { + return this.getToken(PostgreSQLParser.CONSTRAINTS, 0); +}; + +TablelikeoptionContext.prototype.DEFAULTS = function() { + return this.getToken(PostgreSQLParser.DEFAULTS, 0); +}; + +TablelikeoptionContext.prototype.IDENTITY_P = function() { + return this.getToken(PostgreSQLParser.IDENTITY_P, 0); +}; + +TablelikeoptionContext.prototype.GENERATED = function() { + return this.getToken(PostgreSQLParser.GENERATED, 0); +}; + +TablelikeoptionContext.prototype.INDEXES = function() { + return this.getToken(PostgreSQLParser.INDEXES, 0); +}; + +TablelikeoptionContext.prototype.STATISTICS = function() { + return this.getToken(PostgreSQLParser.STATISTICS, 0); +}; + +TablelikeoptionContext.prototype.STORAGE = function() { + return this.getToken(PostgreSQLParser.STORAGE, 0); +}; + +TablelikeoptionContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +TablelikeoptionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTablelikeoption(this); + } +}; + +TablelikeoptionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTablelikeoption(this); + } +}; + +TablelikeoptionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTablelikeoption(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TablelikeoptionContext = TablelikeoptionContext; + +PostgreSQLParser.prototype.tablelikeoption = function() { + + var localctx = new TablelikeoptionContext(this, this._ctx, this.state); + this.enterRule(localctx, 206, PostgreSQLParser.RULE_tablelikeoption); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2911; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.ALL || ((((_la - 160)) & ~0x1f) == 0 && ((1 << (_la - 160)) & ((1 << (PostgreSQLParser.COMMENTS - 160)) | (1 << (PostgreSQLParser.CONSTRAINTS - 160)) | (1 << (PostgreSQLParser.DEFAULTS - 160)))) !== 0) || _la===PostgreSQLParser.IDENTITY_P || _la===PostgreSQLParser.INDEXES || _la===PostgreSQLParser.STATISTICS || _la===PostgreSQLParser.STORAGE || _la===PostgreSQLParser.GENERATED)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TableconstraintContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_tableconstraint; + return this; +} + +TableconstraintContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TableconstraintContext.prototype.constructor = TableconstraintContext; + +TableconstraintContext.prototype.CONSTRAINT = function() { + return this.getToken(PostgreSQLParser.CONSTRAINT, 0); +}; + +TableconstraintContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +TableconstraintContext.prototype.constraintelem = function() { + return this.getTypedRuleContext(ConstraintelemContext,0); +}; + +TableconstraintContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTableconstraint(this); + } +}; + +TableconstraintContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTableconstraint(this); + } +}; + +TableconstraintContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTableconstraint(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TableconstraintContext = TableconstraintContext; + +PostgreSQLParser.prototype.tableconstraint = function() { + + var localctx = new TableconstraintContext(this, this._ctx, this.state); + this.enterRule(localctx, 208, PostgreSQLParser.RULE_tableconstraint); + try { + this.state = 2918; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CONSTRAINT: + this.enterOuterAlt(localctx, 1); + this.state = 2913; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 2914; + this.name(); + this.state = 2915; + this.constraintelem(); + break; + case PostgreSQLParser.CHECK: + case PostgreSQLParser.FOREIGN: + case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.EXCLUDE: + this.enterOuterAlt(localctx, 2); + this.state = 2917; + this.constraintelem(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ConstraintelemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constraintelem; + return this; +} + +ConstraintelemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ConstraintelemContext.prototype.constructor = ConstraintelemContext; + +ConstraintelemContext.prototype.CHECK = function() { + return this.getToken(PostgreSQLParser.CHECK, 0); +}; + +ConstraintelemContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +ConstraintelemContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +ConstraintelemContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +ConstraintelemContext.prototype.constraintattributespec = function() { + return this.getTypedRuleContext(ConstraintattributespecContext,0); +}; + +ConstraintelemContext.prototype.UNIQUE = function() { + return this.getToken(PostgreSQLParser.UNIQUE, 0); +}; + +ConstraintelemContext.prototype.columnlist = function() { + return this.getTypedRuleContext(ColumnlistContext,0); +}; + +ConstraintelemContext.prototype.opt_c_include = function() { + return this.getTypedRuleContext(Opt_c_includeContext,0); +}; + +ConstraintelemContext.prototype.opt_definition = function() { + return this.getTypedRuleContext(Opt_definitionContext,0); +}; + +ConstraintelemContext.prototype.optconstablespace = function() { + return this.getTypedRuleContext(OptconstablespaceContext,0); +}; + +ConstraintelemContext.prototype.existingindex = function() { + return this.getTypedRuleContext(ExistingindexContext,0); +}; + +ConstraintelemContext.prototype.PRIMARY = function() { + return this.getToken(PostgreSQLParser.PRIMARY, 0); +}; + +ConstraintelemContext.prototype.KEY = function() { + return this.getToken(PostgreSQLParser.KEY, 0); +}; + +ConstraintelemContext.prototype.EXCLUDE = function() { + return this.getToken(PostgreSQLParser.EXCLUDE, 0); +}; + +ConstraintelemContext.prototype.access_method_clause = function() { + return this.getTypedRuleContext(Access_method_clauseContext,0); +}; + +ConstraintelemContext.prototype.exclusionconstraintlist = function() { + return this.getTypedRuleContext(ExclusionconstraintlistContext,0); +}; + +ConstraintelemContext.prototype.exclusionwhereclause = function() { + return this.getTypedRuleContext(ExclusionwhereclauseContext,0); +}; + +ConstraintelemContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +ConstraintelemContext.prototype.REFERENCES = function() { + return this.getToken(PostgreSQLParser.REFERENCES, 0); +}; + +ConstraintelemContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +ConstraintelemContext.prototype.opt_column_list = function() { + return this.getTypedRuleContext(Opt_column_listContext,0); +}; + +ConstraintelemContext.prototype.key_match = function() { + return this.getTypedRuleContext(Key_matchContext,0); +}; + +ConstraintelemContext.prototype.key_actions = function() { + return this.getTypedRuleContext(Key_actionsContext,0); +}; + +ConstraintelemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstraintelem(this); + } +}; + +ConstraintelemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstraintelem(this); + } +}; + +ConstraintelemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstraintelem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ConstraintelemContext = ConstraintelemContext; + +PostgreSQLParser.prototype.constraintelem = function() { + + var localctx = new ConstraintelemContext(this, this._ctx, this.state); + this.enterRule(localctx, 210, PostgreSQLParser.RULE_constraintelem); + try { + this.state = 2978; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CHECK: + this.enterOuterAlt(localctx, 1); + this.state = 2920; + this.match(PostgreSQLParser.CHECK); + this.state = 2921; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2922; + this.a_expr(); + this.state = 2923; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 2924; + this.constraintattributespec(); + break; + case PostgreSQLParser.UNIQUE: + this.enterOuterAlt(localctx, 2); + this.state = 2926; + this.match(PostgreSQLParser.UNIQUE); + this.state = 2938; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + this.state = 2927; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2928; + this.columnlist(); + this.state = 2929; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 2930; + this.opt_c_include(); + this.state = 2931; + this.opt_definition(); + this.state = 2932; + this.optconstablespace(); + this.state = 2933; + this.constraintattributespec(); + break; + case PostgreSQLParser.USING: + this.state = 2935; + this.existingindex(); + this.state = 2936; + this.constraintattributespec(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + case PostgreSQLParser.PRIMARY: + this.enterOuterAlt(localctx, 3); + this.state = 2940; + this.match(PostgreSQLParser.PRIMARY); + this.state = 2941; + this.match(PostgreSQLParser.KEY); + this.state = 2953; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + this.state = 2942; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2943; + this.columnlist(); + this.state = 2944; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 2945; + this.opt_c_include(); + this.state = 2946; + this.opt_definition(); + this.state = 2947; + this.optconstablespace(); + this.state = 2948; + this.constraintattributespec(); + break; + case PostgreSQLParser.USING: + this.state = 2950; + this.existingindex(); + this.state = 2951; + this.constraintattributespec(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + case PostgreSQLParser.EXCLUDE: + this.enterOuterAlt(localctx, 4); + this.state = 2955; + this.match(PostgreSQLParser.EXCLUDE); + this.state = 2956; + this.access_method_clause(); + this.state = 2957; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2958; + this.exclusionconstraintlist(); + this.state = 2959; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 2960; + this.opt_c_include(); + this.state = 2961; + this.opt_definition(); + this.state = 2962; + this.optconstablespace(); + this.state = 2963; + this.exclusionwhereclause(); + this.state = 2964; + this.constraintattributespec(); + break; + case PostgreSQLParser.FOREIGN: + this.enterOuterAlt(localctx, 5); + this.state = 2966; + this.match(PostgreSQLParser.FOREIGN); + this.state = 2967; + this.match(PostgreSQLParser.KEY); + this.state = 2968; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2969; + this.columnlist(); + this.state = 2970; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 2971; + this.match(PostgreSQLParser.REFERENCES); + this.state = 2972; + this.qualified_name(); + this.state = 2973; + this.opt_column_list(); + this.state = 2974; + this.key_match(); + this.state = 2975; + this.key_actions(); + this.state = 2976; + this.constraintattributespec(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_no_inheritContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_no_inherit; + return this; +} + +Opt_no_inheritContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_no_inheritContext.prototype.constructor = Opt_no_inheritContext; + +Opt_no_inheritContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Opt_no_inheritContext.prototype.INHERIT = function() { + return this.getToken(PostgreSQLParser.INHERIT, 0); +}; + +Opt_no_inheritContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_no_inherit(this); + } +}; + +Opt_no_inheritContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_no_inherit(this); + } +}; + +Opt_no_inheritContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_no_inherit(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_no_inheritContext = Opt_no_inheritContext; + +PostgreSQLParser.prototype.opt_no_inherit = function() { + + var localctx = new Opt_no_inheritContext(this, this._ctx, this.state); + this.enterRule(localctx, 212, PostgreSQLParser.RULE_opt_no_inherit); + try { + this.state = 2983; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NO: + this.enterOuterAlt(localctx, 1); + this.state = 2980; + this.match(PostgreSQLParser.NO); + this.state = 2981; + this.match(PostgreSQLParser.INHERIT); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CHECK: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INITIALLY: + case PostgreSQLParser.INTO: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.REFERENCES: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_column_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_column_list; + return this; +} + +Opt_column_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_column_listContext.prototype.constructor = Opt_column_listContext; + +Opt_column_listContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opt_column_listContext.prototype.columnlist = function() { + return this.getTypedRuleContext(ColumnlistContext,0); +}; + +Opt_column_listContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opt_column_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_column_list(this); + } +}; + +Opt_column_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_column_list(this); + } +}; + +Opt_column_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_column_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_column_listContext = Opt_column_listContext; + +PostgreSQLParser.prototype.opt_column_list = function() { + + var localctx = new Opt_column_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 214, PostgreSQLParser.RULE_opt_column_list); + try { + this.state = 2990; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,103,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 2985; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 2986; + this.columnlist(); + this.state = 2987; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ColumnlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_columnlist; + return this; +} + +ColumnlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ColumnlistContext.prototype.constructor = ColumnlistContext; + +ColumnlistContext.prototype.columnElem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(ColumnElemContext); + } else { + return this.getTypedRuleContext(ColumnElemContext,i); + } +}; + +ColumnlistContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +ColumnlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterColumnlist(this); + } +}; + +ColumnlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitColumnlist(this); + } +}; + +ColumnlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitColumnlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ColumnlistContext = ColumnlistContext; + +PostgreSQLParser.prototype.columnlist = function() { + + var localctx = new ColumnlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 216, PostgreSQLParser.RULE_columnlist); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 2992; + this.columnElem(); + this.state = 2997; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 2993; + this.match(PostgreSQLParser.COMMA); + this.state = 2994; + this.columnElem(); + this.state = 2999; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ColumnElemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_columnElem; + return this; +} + +ColumnElemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ColumnElemContext.prototype.constructor = ColumnElemContext; + +ColumnElemContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +ColumnElemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterColumnElem(this); + } +}; + +ColumnElemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitColumnElem(this); + } +}; + +ColumnElemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitColumnElem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ColumnElemContext = ColumnElemContext; + +PostgreSQLParser.prototype.columnElem = function() { + + var localctx = new ColumnElemContext(this, this._ctx, this.state); + this.enterRule(localctx, 218, PostgreSQLParser.RULE_columnElem); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3000; + this.colid(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_c_includeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_c_include; + return this; +} + +Opt_c_includeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_c_includeContext.prototype.constructor = Opt_c_includeContext; + +Opt_c_includeContext.prototype.INCLUDE = function() { + return this.getToken(PostgreSQLParser.INCLUDE, 0); +}; + +Opt_c_includeContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opt_c_includeContext.prototype.columnlist = function() { + return this.getTypedRuleContext(ColumnlistContext,0); +}; + +Opt_c_includeContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opt_c_includeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_c_include(this); + } +}; + +Opt_c_includeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_c_include(this); + } +}; + +Opt_c_includeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_c_include(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_c_includeContext = Opt_c_includeContext; + +PostgreSQLParser.prototype.opt_c_include = function() { + + var localctx = new Opt_c_includeContext(this, this._ctx, this.state); + this.enterRule(localctx, 220, PostgreSQLParser.RULE_opt_c_include); + try { + this.state = 3008; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.INCLUDE: + this.enterOuterAlt(localctx, 1); + this.state = 3002; + this.match(PostgreSQLParser.INCLUDE); + this.state = 3003; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3004; + this.columnlist(); + this.state = 3005; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INITIALLY: + case PostgreSQLParser.INTO: + case PostgreSQLParser.NOT: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.USING: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Key_matchContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_key_match; + return this; +} + +Key_matchContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Key_matchContext.prototype.constructor = Key_matchContext; + +Key_matchContext.prototype.MATCH = function() { + return this.getToken(PostgreSQLParser.MATCH, 0); +}; + +Key_matchContext.prototype.FULL = function() { + return this.getToken(PostgreSQLParser.FULL, 0); +}; + +Key_matchContext.prototype.PARTIAL = function() { + return this.getToken(PostgreSQLParser.PARTIAL, 0); +}; + +Key_matchContext.prototype.SIMPLE = function() { + return this.getToken(PostgreSQLParser.SIMPLE, 0); +}; + +Key_matchContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterKey_match(this); + } +}; + +Key_matchContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitKey_match(this); + } +}; + +Key_matchContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitKey_match(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Key_matchContext = Key_matchContext; + +PostgreSQLParser.prototype.key_match = function() { + + var localctx = new Key_matchContext(this, this._ctx, this.state); + this.enterRule(localctx, 222, PostgreSQLParser.RULE_key_match); + var _la = 0; // Token type + try { + this.state = 3013; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.MATCH: + this.enterOuterAlt(localctx, 1); + this.state = 3010; + this.match(PostgreSQLParser.MATCH); + this.state = 3011; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FULL || _la===PostgreSQLParser.PARTIAL || _la===PostgreSQLParser.SIMPLE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CHECK: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INITIALLY: + case PostgreSQLParser.INTO: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.ON: + case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.REFERENCES: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ExclusionconstraintlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_exclusionconstraintlist; + return this; +} + +ExclusionconstraintlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ExclusionconstraintlistContext.prototype.constructor = ExclusionconstraintlistContext; + +ExclusionconstraintlistContext.prototype.exclusionconstraintelem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(ExclusionconstraintelemContext); + } else { + return this.getTypedRuleContext(ExclusionconstraintelemContext,i); + } +}; + +ExclusionconstraintlistContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +ExclusionconstraintlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExclusionconstraintlist(this); + } +}; + +ExclusionconstraintlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExclusionconstraintlist(this); + } +}; + +ExclusionconstraintlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExclusionconstraintlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ExclusionconstraintlistContext = ExclusionconstraintlistContext; + +PostgreSQLParser.prototype.exclusionconstraintlist = function() { + + var localctx = new ExclusionconstraintlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 224, PostgreSQLParser.RULE_exclusionconstraintlist); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3015; + this.exclusionconstraintelem(); + this.state = 3020; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 3016; + this.match(PostgreSQLParser.COMMA); + this.state = 3017; + this.exclusionconstraintelem(); + this.state = 3022; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ExclusionconstraintelemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_exclusionconstraintelem; + return this; +} + +ExclusionconstraintelemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ExclusionconstraintelemContext.prototype.constructor = ExclusionconstraintelemContext; + +ExclusionconstraintelemContext.prototype.index_elem = function() { + return this.getTypedRuleContext(Index_elemContext,0); +}; + +ExclusionconstraintelemContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +ExclusionconstraintelemContext.prototype.any_operator = function() { + return this.getTypedRuleContext(Any_operatorContext,0); +}; + +ExclusionconstraintelemContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +ExclusionconstraintelemContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +ExclusionconstraintelemContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +ExclusionconstraintelemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExclusionconstraintelem(this); + } +}; + +ExclusionconstraintelemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExclusionconstraintelem(this); + } +}; + +ExclusionconstraintelemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExclusionconstraintelem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ExclusionconstraintelemContext = ExclusionconstraintelemContext; + +PostgreSQLParser.prototype.exclusionconstraintelem = function() { + + var localctx = new ExclusionconstraintelemContext(this, this._ctx, this.state); + this.enterRule(localctx, 226, PostgreSQLParser.RULE_exclusionconstraintelem); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3023; + this.index_elem(); + this.state = 3024; + this.match(PostgreSQLParser.WITH); + this.state = 3031; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,108,this._ctx); + switch(la_) { + case 1: + this.state = 3025; + this.any_operator(); + break; + + case 2: + this.state = 3026; + this.match(PostgreSQLParser.OPERATOR); + this.state = 3027; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3028; + this.any_operator(); + this.state = 3029; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ExclusionwhereclauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_exclusionwhereclause; + return this; +} + +ExclusionwhereclauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ExclusionwhereclauseContext.prototype.constructor = ExclusionwhereclauseContext; + +ExclusionwhereclauseContext.prototype.WHERE = function() { + return this.getToken(PostgreSQLParser.WHERE, 0); +}; + +ExclusionwhereclauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +ExclusionwhereclauseContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +ExclusionwhereclauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +ExclusionwhereclauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExclusionwhereclause(this); + } +}; + +ExclusionwhereclauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExclusionwhereclause(this); + } +}; + +ExclusionwhereclauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExclusionwhereclause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ExclusionwhereclauseContext = ExclusionwhereclauseContext; + +PostgreSQLParser.prototype.exclusionwhereclause = function() { + + var localctx = new ExclusionwhereclauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 228, PostgreSQLParser.RULE_exclusionwhereclause); + try { + this.state = 3039; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.WHERE: + this.enterOuterAlt(localctx, 1); + this.state = 3033; + this.match(PostgreSQLParser.WHERE); + this.state = 3034; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3035; + this.a_expr(); + this.state = 3036; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INITIALLY: + case PostgreSQLParser.INTO: + case PostgreSQLParser.NOT: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Key_actionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_key_actions; + return this; +} + +Key_actionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Key_actionsContext.prototype.constructor = Key_actionsContext; + +Key_actionsContext.prototype.key_update = function() { + return this.getTypedRuleContext(Key_updateContext,0); +}; + +Key_actionsContext.prototype.key_delete = function() { + return this.getTypedRuleContext(Key_deleteContext,0); +}; + +Key_actionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterKey_actions(this); + } +}; + +Key_actionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitKey_actions(this); + } +}; + +Key_actionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitKey_actions(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Key_actionsContext = Key_actionsContext; + +PostgreSQLParser.prototype.key_actions = function() { + + var localctx = new Key_actionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 230, PostgreSQLParser.RULE_key_actions); + try { + this.state = 3050; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,110,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3041; + this.key_update(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3042; + this.key_delete(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 3043; + this.key_update(); + this.state = 3044; + this.key_delete(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 3046; + this.key_delete(); + this.state = 3047; + this.key_update(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Key_updateContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_key_update; + return this; +} + +Key_updateContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Key_updateContext.prototype.constructor = Key_updateContext; + +Key_updateContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +Key_updateContext.prototype.UPDATE = function() { + return this.getToken(PostgreSQLParser.UPDATE, 0); +}; + +Key_updateContext.prototype.key_action = function() { + return this.getTypedRuleContext(Key_actionContext,0); +}; + +Key_updateContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterKey_update(this); + } +}; + +Key_updateContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitKey_update(this); + } +}; + +Key_updateContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitKey_update(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Key_updateContext = Key_updateContext; + +PostgreSQLParser.prototype.key_update = function() { + + var localctx = new Key_updateContext(this, this._ctx, this.state); + this.enterRule(localctx, 232, PostgreSQLParser.RULE_key_update); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3052; + this.match(PostgreSQLParser.ON); + this.state = 3053; + this.match(PostgreSQLParser.UPDATE); + this.state = 3054; + this.key_action(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Key_deleteContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_key_delete; + return this; +} + +Key_deleteContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Key_deleteContext.prototype.constructor = Key_deleteContext; + +Key_deleteContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +Key_deleteContext.prototype.DELETE_P = function() { + return this.getToken(PostgreSQLParser.DELETE_P, 0); +}; + +Key_deleteContext.prototype.key_action = function() { + return this.getTypedRuleContext(Key_actionContext,0); +}; + +Key_deleteContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterKey_delete(this); + } +}; + +Key_deleteContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitKey_delete(this); + } +}; + +Key_deleteContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitKey_delete(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Key_deleteContext = Key_deleteContext; + +PostgreSQLParser.prototype.key_delete = function() { + + var localctx = new Key_deleteContext(this, this._ctx, this.state); + this.enterRule(localctx, 234, PostgreSQLParser.RULE_key_delete); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3056; + this.match(PostgreSQLParser.ON); + this.state = 3057; + this.match(PostgreSQLParser.DELETE_P); + this.state = 3058; + this.key_action(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Key_actionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_key_action; + return this; +} + +Key_actionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Key_actionContext.prototype.constructor = Key_actionContext; + +Key_actionContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Key_actionContext.prototype.ACTION = function() { + return this.getToken(PostgreSQLParser.ACTION, 0); +}; + +Key_actionContext.prototype.RESTRICT = function() { + return this.getToken(PostgreSQLParser.RESTRICT, 0); +}; + +Key_actionContext.prototype.CASCADE = function() { + return this.getToken(PostgreSQLParser.CASCADE, 0); +}; + +Key_actionContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +Key_actionContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +Key_actionContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Key_actionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterKey_action(this); + } +}; + +Key_actionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitKey_action(this); + } +}; + +Key_actionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitKey_action(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Key_actionContext = Key_actionContext; + +PostgreSQLParser.prototype.key_action = function() { + + var localctx = new Key_actionContext(this, this._ctx, this.state); + this.enterRule(localctx, 236, PostgreSQLParser.RULE_key_action); + var _la = 0; // Token type + try { + this.state = 3066; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NO: + this.enterOuterAlt(localctx, 1); + this.state = 3060; + this.match(PostgreSQLParser.NO); + this.state = 3061; + this.match(PostgreSQLParser.ACTION); + break; + case PostgreSQLParser.RESTRICT: + this.enterOuterAlt(localctx, 2); + this.state = 3062; + this.match(PostgreSQLParser.RESTRICT); + break; + case PostgreSQLParser.CASCADE: + this.enterOuterAlt(localctx, 3); + this.state = 3063; + this.match(PostgreSQLParser.CASCADE); + break; + case PostgreSQLParser.SET: + this.enterOuterAlt(localctx, 4); + this.state = 3064; + this.match(PostgreSQLParser.SET); + this.state = 3065; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.DEFAULT || _la===PostgreSQLParser.NULL_P)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptinheritContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optinherit; + return this; +} + +OptinheritContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptinheritContext.prototype.constructor = OptinheritContext; + +OptinheritContext.prototype.INHERITS = function() { + return this.getToken(PostgreSQLParser.INHERITS, 0); +}; + +OptinheritContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +OptinheritContext.prototype.qualified_name_list = function() { + return this.getTypedRuleContext(Qualified_name_listContext,0); +}; + +OptinheritContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +OptinheritContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptinherit(this); + } +}; + +OptinheritContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptinherit(this); + } +}; + +OptinheritContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptinherit(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptinheritContext = OptinheritContext; + +PostgreSQLParser.prototype.optinherit = function() { + + var localctx = new OptinheritContext(this, this._ctx, this.state); + this.enterRule(localctx, 238, PostgreSQLParser.RULE_optinherit); + try { + this.state = 3074; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.INHERITS: + this.enterOuterAlt(localctx, 1); + this.state = 3068; + this.match(PostgreSQLParser.INHERITS); + this.state = 3069; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3070; + this.qualified_name_list(); + this.state = 3071; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.ON: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.USING: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptpartitionspecContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optpartitionspec; + return this; +} + +OptpartitionspecContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptpartitionspecContext.prototype.constructor = OptpartitionspecContext; + +OptpartitionspecContext.prototype.partitionspec = function() { + return this.getTypedRuleContext(PartitionspecContext,0); +}; + +OptpartitionspecContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptpartitionspec(this); + } +}; + +OptpartitionspecContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptpartitionspec(this); + } +}; + +OptpartitionspecContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptpartitionspec(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptpartitionspecContext = OptpartitionspecContext; + +PostgreSQLParser.prototype.optpartitionspec = function() { + + var localctx = new OptpartitionspecContext(this, this._ctx, this.state); + this.enterRule(localctx, 240, PostgreSQLParser.RULE_optpartitionspec); + try { + this.state = 3078; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.PARTITION: + this.enterOuterAlt(localctx, 1); + this.state = 3076; + this.partitionspec(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.ON: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.USING: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function PartitionspecContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_partitionspec; + return this; +} + +PartitionspecContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +PartitionspecContext.prototype.constructor = PartitionspecContext; + +PartitionspecContext.prototype.PARTITION = function() { + return this.getToken(PostgreSQLParser.PARTITION, 0); +}; + +PartitionspecContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +PartitionspecContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +PartitionspecContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +PartitionspecContext.prototype.part_params = function() { + return this.getTypedRuleContext(Part_paramsContext,0); +}; + +PartitionspecContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +PartitionspecContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPartitionspec(this); + } +}; + +PartitionspecContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPartitionspec(this); + } +}; + +PartitionspecContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPartitionspec(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.PartitionspecContext = PartitionspecContext; + +PostgreSQLParser.prototype.partitionspec = function() { + + var localctx = new PartitionspecContext(this, this._ctx, this.state); + this.enterRule(localctx, 242, PostgreSQLParser.RULE_partitionspec); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3080; + this.match(PostgreSQLParser.PARTITION); + this.state = 3081; + this.match(PostgreSQLParser.BY); + this.state = 3082; + this.colid(); + this.state = 3083; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3084; + this.part_params(); + this.state = 3085; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Part_paramsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_part_params; + return this; +} + +Part_paramsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Part_paramsContext.prototype.constructor = Part_paramsContext; + +Part_paramsContext.prototype.part_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Part_elemContext); + } else { + return this.getTypedRuleContext(Part_elemContext,i); + } +}; + +Part_paramsContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Part_paramsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPart_params(this); + } +}; + +Part_paramsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPart_params(this); + } +}; + +Part_paramsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPart_params(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Part_paramsContext = Part_paramsContext; + +PostgreSQLParser.prototype.part_params = function() { + + var localctx = new Part_paramsContext(this, this._ctx, this.state); + this.enterRule(localctx, 244, PostgreSQLParser.RULE_part_params); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3087; + this.part_elem(); + this.state = 3092; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 3088; + this.match(PostgreSQLParser.COMMA); + this.state = 3089; + this.part_elem(); + this.state = 3094; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Part_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_part_elem; + return this; +} + +Part_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Part_elemContext.prototype.constructor = Part_elemContext; + +Part_elemContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Part_elemContext.prototype.opt_collate = function() { + return this.getTypedRuleContext(Opt_collateContext,0); +}; + +Part_elemContext.prototype.opt_class = function() { + return this.getTypedRuleContext(Opt_classContext,0); +}; + +Part_elemContext.prototype.func_expr_windowless = function() { + return this.getTypedRuleContext(Func_expr_windowlessContext,0); +}; + +Part_elemContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Part_elemContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Part_elemContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Part_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPart_elem(this); + } +}; + +Part_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPart_elem(this); + } +}; + +Part_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPart_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Part_elemContext = Part_elemContext; + +PostgreSQLParser.prototype.part_elem = function() { + + var localctx = new Part_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 246, PostgreSQLParser.RULE_part_elem); + try { + this.state = 3109; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,115,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3095; + this.colid(); + this.state = 3096; + this.opt_collate(); + this.state = 3097; + this.opt_class(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3099; + this.func_expr_windowless(); + this.state = 3100; + this.opt_collate(); + this.state = 3101; + this.opt_class(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 3103; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3104; + this.a_expr(); + this.state = 3105; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 3106; + this.opt_collate(); + this.state = 3107; + this.opt_class(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Table_access_method_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_table_access_method_clause; + return this; +} + +Table_access_method_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Table_access_method_clauseContext.prototype.constructor = Table_access_method_clauseContext; + +Table_access_method_clauseContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Table_access_method_clauseContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Table_access_method_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTable_access_method_clause(this); + } +}; + +Table_access_method_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTable_access_method_clause(this); + } +}; + +Table_access_method_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTable_access_method_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Table_access_method_clauseContext = Table_access_method_clauseContext; + +PostgreSQLParser.prototype.table_access_method_clause = function() { + + var localctx = new Table_access_method_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 248, PostgreSQLParser.RULE_table_access_method_clause); + try { + this.state = 3114; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + this.state = 3111; + this.match(PostgreSQLParser.USING); + this.state = 3112; + this.name(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AS: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.ON: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptwithContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optwith; + return this; +} + +OptwithContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptwithContext.prototype.constructor = OptwithContext; + +OptwithContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +OptwithContext.prototype.reloptions = function() { + return this.getTypedRuleContext(ReloptionsContext,0); +}; + +OptwithContext.prototype.WITHOUT = function() { + return this.getToken(PostgreSQLParser.WITHOUT, 0); +}; + +OptwithContext.prototype.OIDS = function() { + return this.getToken(PostgreSQLParser.OIDS, 0); +}; + +OptwithContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptwith(this); + } +}; + +OptwithContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptwith(this); + } +}; + +OptwithContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptwith(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptwithContext = OptwithContext; + +PostgreSQLParser.prototype.optwith = function() { + + var localctx = new OptwithContext(this, this._ctx, this.state); + this.enterRule(localctx, 250, PostgreSQLParser.RULE_optwith); + try { + this.state = 3121; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,117,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3116; + this.match(PostgreSQLParser.WITH); + this.state = 3117; + this.reloptions(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3118; + this.match(PostgreSQLParser.WITHOUT); + this.state = 3119; + this.match(PostgreSQLParser.OIDS); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OncommitoptionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_oncommitoption; + return this; +} + +OncommitoptionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OncommitoptionContext.prototype.constructor = OncommitoptionContext; + +OncommitoptionContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +OncommitoptionContext.prototype.COMMIT = function() { + return this.getToken(PostgreSQLParser.COMMIT, 0); +}; + +OncommitoptionContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +OncommitoptionContext.prototype.DELETE_P = function() { + return this.getToken(PostgreSQLParser.DELETE_P, 0); +}; + +OncommitoptionContext.prototype.ROWS = function() { + return this.getToken(PostgreSQLParser.ROWS, 0); +}; + +OncommitoptionContext.prototype.PRESERVE = function() { + return this.getToken(PostgreSQLParser.PRESERVE, 0); +}; + +OncommitoptionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOncommitoption(this); + } +}; + +OncommitoptionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOncommitoption(this); + } +}; + +OncommitoptionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOncommitoption(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OncommitoptionContext = OncommitoptionContext; + +PostgreSQLParser.prototype.oncommitoption = function() { + + var localctx = new OncommitoptionContext(this, this._ctx, this.state); + this.enterRule(localctx, 252, PostgreSQLParser.RULE_oncommitoption); + try { + this.state = 3133; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ON: + this.enterOuterAlt(localctx, 1); + this.state = 3123; + this.match(PostgreSQLParser.ON); + this.state = 3124; + this.match(PostgreSQLParser.COMMIT); + this.state = 3130; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.DROP: + this.state = 3125; + this.match(PostgreSQLParser.DROP); + break; + case PostgreSQLParser.DELETE_P: + this.state = 3126; + this.match(PostgreSQLParser.DELETE_P); + this.state = 3127; + this.match(PostgreSQLParser.ROWS); + break; + case PostgreSQLParser.PRESERVE: + this.state = 3128; + this.match(PostgreSQLParser.PRESERVE); + this.state = 3129; + this.match(PostgreSQLParser.ROWS); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AS: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OpttablespaceContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opttablespace; + return this; +} + +OpttablespaceContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OpttablespaceContext.prototype.constructor = OpttablespaceContext; + +OpttablespaceContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +OpttablespaceContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +OpttablespaceContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpttablespace(this); + } +}; + +OpttablespaceContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpttablespace(this); + } +}; + +OpttablespaceContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpttablespace(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OpttablespaceContext = OpttablespaceContext; + +PostgreSQLParser.prototype.opttablespace = function() { + + var localctx = new OpttablespaceContext(this, this._ctx, this.state); + this.enterRule(localctx, 254, PostgreSQLParser.RULE_opttablespace); + try { + this.state = 3138; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.TABLESPACE: + this.enterOuterAlt(localctx, 1); + this.state = 3135; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 3136; + this.name(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AS: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptconstablespaceContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optconstablespace; + return this; +} + +OptconstablespaceContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptconstablespaceContext.prototype.constructor = OptconstablespaceContext; + +OptconstablespaceContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +OptconstablespaceContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +OptconstablespaceContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +OptconstablespaceContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +OptconstablespaceContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptconstablespace(this); + } +}; + +OptconstablespaceContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptconstablespace(this); + } +}; + +OptconstablespaceContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptconstablespace(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptconstablespaceContext = OptconstablespaceContext; + +PostgreSQLParser.prototype.optconstablespace = function() { + + var localctx = new OptconstablespaceContext(this, this._ctx, this.state); + this.enterRule(localctx, 256, PostgreSQLParser.RULE_optconstablespace); + try { + this.state = 3145; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + this.state = 3140; + this.match(PostgreSQLParser.USING); + this.state = 3141; + this.match(PostgreSQLParser.INDEX); + this.state = 3142; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 3143; + this.name(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CHECK: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INITIALLY: + case PostgreSQLParser.INTO: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.REFERENCES: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ExistingindexContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_existingindex; + return this; +} + +ExistingindexContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ExistingindexContext.prototype.constructor = ExistingindexContext; + +ExistingindexContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +ExistingindexContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +ExistingindexContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +ExistingindexContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExistingindex(this); + } +}; + +ExistingindexContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExistingindex(this); + } +}; + +ExistingindexContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExistingindex(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ExistingindexContext = ExistingindexContext; + +PostgreSQLParser.prototype.existingindex = function() { + + var localctx = new ExistingindexContext(this, this._ctx, this.state); + this.enterRule(localctx, 258, PostgreSQLParser.RULE_existingindex); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3147; + this.match(PostgreSQLParser.USING); + this.state = 3148; + this.match(PostgreSQLParser.INDEX); + this.state = 3149; + this.name(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatestatsstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createstatsstmt; + return this; +} + +CreatestatsstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatestatsstmtContext.prototype.constructor = CreatestatsstmtContext; + +CreatestatsstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatestatsstmtContext.prototype.STATISTICS = function() { + return this.getToken(PostgreSQLParser.STATISTICS, 0); +}; + +CreatestatsstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +CreatestatsstmtContext.prototype.opt_name_list = function() { + return this.getTypedRuleContext(Opt_name_listContext,0); +}; + +CreatestatsstmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +CreatestatsstmtContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +CreatestatsstmtContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +CreatestatsstmtContext.prototype.from_list = function() { + return this.getTypedRuleContext(From_listContext,0); +}; + +CreatestatsstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +CreatestatsstmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +CreatestatsstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +CreatestatsstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatestatsstmt(this); + } +}; + +CreatestatsstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatestatsstmt(this); + } +}; + +CreatestatsstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatestatsstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatestatsstmtContext = CreatestatsstmtContext; + +PostgreSQLParser.prototype.createstatsstmt = function() { + + var localctx = new CreatestatsstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 260, PostgreSQLParser.RULE_createstatsstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3151; + this.match(PostgreSQLParser.CREATE); + this.state = 3152; + this.match(PostgreSQLParser.STATISTICS); + this.state = 3156; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,122,this._ctx); + if(la_===1) { + this.state = 3153; + this.match(PostgreSQLParser.IF_P); + this.state = 3154; + this.match(PostgreSQLParser.NOT); + this.state = 3155; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 3158; + this.any_name(); + this.state = 3159; + this.opt_name_list(); + this.state = 3160; + this.match(PostgreSQLParser.ON); + this.state = 3161; + this.expr_list(); + this.state = 3162; + this.match(PostgreSQLParser.FROM); + this.state = 3163; + this.from_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterstatsstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterstatsstmt; + return this; +} + +AlterstatsstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterstatsstmtContext.prototype.constructor = AlterstatsstmtContext; + +AlterstatsstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterstatsstmtContext.prototype.STATISTICS = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.STATISTICS); + } else { + return this.getToken(PostgreSQLParser.STATISTICS, i); + } +}; + + +AlterstatsstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AlterstatsstmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AlterstatsstmtContext.prototype.signediconst = function() { + return this.getTypedRuleContext(SignediconstContext,0); +}; + +AlterstatsstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +AlterstatsstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +AlterstatsstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterstatsstmt(this); + } +}; + +AlterstatsstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterstatsstmt(this); + } +}; + +AlterstatsstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterstatsstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterstatsstmtContext = AlterstatsstmtContext; + +PostgreSQLParser.prototype.alterstatsstmt = function() { + + var localctx = new AlterstatsstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 262, PostgreSQLParser.RULE_alterstatsstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3165; + this.match(PostgreSQLParser.ALTER); + this.state = 3166; + this.match(PostgreSQLParser.STATISTICS); + this.state = 3169; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,123,this._ctx); + if(la_===1) { + this.state = 3167; + this.match(PostgreSQLParser.IF_P); + this.state = 3168; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 3171; + this.any_name(); + this.state = 3172; + this.match(PostgreSQLParser.SET); + this.state = 3173; + this.match(PostgreSQLParser.STATISTICS); + this.state = 3174; + this.signediconst(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateasstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createasstmt; + return this; +} + +CreateasstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateasstmtContext.prototype.constructor = CreateasstmtContext; + +CreateasstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateasstmtContext.prototype.opttemp = function() { + return this.getTypedRuleContext(OpttempContext,0); +}; + +CreateasstmtContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +CreateasstmtContext.prototype.create_as_target = function() { + return this.getTypedRuleContext(Create_as_targetContext,0); +}; + +CreateasstmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +CreateasstmtContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +CreateasstmtContext.prototype.opt_with_data = function() { + return this.getTypedRuleContext(Opt_with_dataContext,0); +}; + +CreateasstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +CreateasstmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +CreateasstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +CreateasstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateasstmt(this); + } +}; + +CreateasstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateasstmt(this); + } +}; + +CreateasstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateasstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateasstmtContext = CreateasstmtContext; + +PostgreSQLParser.prototype.createasstmt = function() { + + var localctx = new CreateasstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 264, PostgreSQLParser.RULE_createasstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3176; + this.match(PostgreSQLParser.CREATE); + this.state = 3177; + this.opttemp(); + this.state = 3178; + this.match(PostgreSQLParser.TABLE); + this.state = 3182; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,124,this._ctx); + if(la_===1) { + this.state = 3179; + this.match(PostgreSQLParser.IF_P); + this.state = 3180; + this.match(PostgreSQLParser.NOT); + this.state = 3181; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 3184; + this.create_as_target(); + this.state = 3185; + this.match(PostgreSQLParser.AS); + this.state = 3186; + this.selectstmt(); + this.state = 3187; + this.opt_with_data(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Create_as_targetContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_create_as_target; + return this; +} + +Create_as_targetContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Create_as_targetContext.prototype.constructor = Create_as_targetContext; + +Create_as_targetContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +Create_as_targetContext.prototype.opt_column_list = function() { + return this.getTypedRuleContext(Opt_column_listContext,0); +}; + +Create_as_targetContext.prototype.table_access_method_clause = function() { + return this.getTypedRuleContext(Table_access_method_clauseContext,0); +}; + +Create_as_targetContext.prototype.optwith = function() { + return this.getTypedRuleContext(OptwithContext,0); +}; + +Create_as_targetContext.prototype.oncommitoption = function() { + return this.getTypedRuleContext(OncommitoptionContext,0); +}; + +Create_as_targetContext.prototype.opttablespace = function() { + return this.getTypedRuleContext(OpttablespaceContext,0); +}; + +Create_as_targetContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreate_as_target(this); + } +}; + +Create_as_targetContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreate_as_target(this); + } +}; + +Create_as_targetContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreate_as_target(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Create_as_targetContext = Create_as_targetContext; + +PostgreSQLParser.prototype.create_as_target = function() { + + var localctx = new Create_as_targetContext(this, this._ctx, this.state); + this.enterRule(localctx, 266, PostgreSQLParser.RULE_create_as_target); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3189; + this.qualified_name(); + this.state = 3190; + this.opt_column_list(); + this.state = 3191; + this.table_access_method_clause(); + this.state = 3192; + this.optwith(); + this.state = 3193; + this.oncommitoption(); + this.state = 3194; + this.opttablespace(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_with_dataContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_with_data; + return this; +} + +Opt_with_dataContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_with_dataContext.prototype.constructor = Opt_with_dataContext; + +Opt_with_dataContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Opt_with_dataContext.prototype.DATA_P = function() { + return this.getToken(PostgreSQLParser.DATA_P, 0); +}; + +Opt_with_dataContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Opt_with_dataContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_with_data(this); + } +}; + +Opt_with_dataContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_with_data(this); + } +}; + +Opt_with_dataContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_with_data(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_with_dataContext = Opt_with_dataContext; + +PostgreSQLParser.prototype.opt_with_data = function() { + + var localctx = new Opt_with_dataContext(this, this._ctx, this.state); + this.enterRule(localctx, 268, PostgreSQLParser.RULE_opt_with_data); + try { + this.state = 3203; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,126,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3196; + this.match(PostgreSQLParser.WITH); + this.state = 3200; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.DATA_P: + this.state = 3197; + this.match(PostgreSQLParser.DATA_P); + break; + case PostgreSQLParser.NO: + this.state = 3198; + this.match(PostgreSQLParser.NO); + this.state = 3199; + this.match(PostgreSQLParser.DATA_P); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatematviewstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_creatematviewstmt; + return this; +} + +CreatematviewstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatematviewstmtContext.prototype.constructor = CreatematviewstmtContext; + +CreatematviewstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatematviewstmtContext.prototype.optnolog = function() { + return this.getTypedRuleContext(OptnologContext,0); +}; + +CreatematviewstmtContext.prototype.MATERIALIZED = function() { + return this.getToken(PostgreSQLParser.MATERIALIZED, 0); +}; + +CreatematviewstmtContext.prototype.VIEW = function() { + return this.getToken(PostgreSQLParser.VIEW, 0); +}; + +CreatematviewstmtContext.prototype.create_mv_target = function() { + return this.getTypedRuleContext(Create_mv_targetContext,0); +}; + +CreatematviewstmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +CreatematviewstmtContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +CreatematviewstmtContext.prototype.opt_with_data = function() { + return this.getTypedRuleContext(Opt_with_dataContext,0); +}; + +CreatematviewstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +CreatematviewstmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +CreatematviewstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +CreatematviewstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatematviewstmt(this); + } +}; + +CreatematviewstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatematviewstmt(this); + } +}; + +CreatematviewstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatematviewstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatematviewstmtContext = CreatematviewstmtContext; + +PostgreSQLParser.prototype.creatematviewstmt = function() { + + var localctx = new CreatematviewstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 270, PostgreSQLParser.RULE_creatematviewstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3205; + this.match(PostgreSQLParser.CREATE); + this.state = 3206; + this.optnolog(); + this.state = 3207; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 3208; + this.match(PostgreSQLParser.VIEW); + this.state = 3212; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,127,this._ctx); + if(la_===1) { + this.state = 3209; + this.match(PostgreSQLParser.IF_P); + this.state = 3210; + this.match(PostgreSQLParser.NOT); + this.state = 3211; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 3214; + this.create_mv_target(); + this.state = 3215; + this.match(PostgreSQLParser.AS); + this.state = 3216; + this.selectstmt(); + this.state = 3217; + this.opt_with_data(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Create_mv_targetContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_create_mv_target; + return this; +} + +Create_mv_targetContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Create_mv_targetContext.prototype.constructor = Create_mv_targetContext; + +Create_mv_targetContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +Create_mv_targetContext.prototype.opt_column_list = function() { + return this.getTypedRuleContext(Opt_column_listContext,0); +}; + +Create_mv_targetContext.prototype.table_access_method_clause = function() { + return this.getTypedRuleContext(Table_access_method_clauseContext,0); +}; + +Create_mv_targetContext.prototype.opt_reloptions = function() { + return this.getTypedRuleContext(Opt_reloptionsContext,0); +}; + +Create_mv_targetContext.prototype.opttablespace = function() { + return this.getTypedRuleContext(OpttablespaceContext,0); +}; + +Create_mv_targetContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreate_mv_target(this); + } +}; + +Create_mv_targetContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreate_mv_target(this); + } +}; + +Create_mv_targetContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreate_mv_target(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Create_mv_targetContext = Create_mv_targetContext; + +PostgreSQLParser.prototype.create_mv_target = function() { + + var localctx = new Create_mv_targetContext(this, this._ctx, this.state); + this.enterRule(localctx, 272, PostgreSQLParser.RULE_create_mv_target); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3219; + this.qualified_name(); + this.state = 3220; + this.opt_column_list(); + this.state = 3221; + this.table_access_method_clause(); + this.state = 3222; + this.opt_reloptions(); + this.state = 3223; + this.opttablespace(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptnologContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optnolog; + return this; +} + +OptnologContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptnologContext.prototype.constructor = OptnologContext; + +OptnologContext.prototype.UNLOGGED = function() { + return this.getToken(PostgreSQLParser.UNLOGGED, 0); +}; + +OptnologContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptnolog(this); + } +}; + +OptnologContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptnolog(this); + } +}; + +OptnologContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptnolog(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptnologContext = OptnologContext; + +PostgreSQLParser.prototype.optnolog = function() { + + var localctx = new OptnologContext(this, this._ctx, this.state); + this.enterRule(localctx, 274, PostgreSQLParser.RULE_optnolog); + try { + this.state = 3227; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.UNLOGGED: + this.enterOuterAlt(localctx, 1); + this.state = 3225; + this.match(PostgreSQLParser.UNLOGGED); + break; + case PostgreSQLParser.MATERIALIZED: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RefreshmatviewstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_refreshmatviewstmt; + return this; +} + +RefreshmatviewstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RefreshmatviewstmtContext.prototype.constructor = RefreshmatviewstmtContext; + +RefreshmatviewstmtContext.prototype.REFRESH = function() { + return this.getToken(PostgreSQLParser.REFRESH, 0); +}; + +RefreshmatviewstmtContext.prototype.MATERIALIZED = function() { + return this.getToken(PostgreSQLParser.MATERIALIZED, 0); +}; + +RefreshmatviewstmtContext.prototype.VIEW = function() { + return this.getToken(PostgreSQLParser.VIEW, 0); +}; + +RefreshmatviewstmtContext.prototype.opt_concurrently = function() { + return this.getTypedRuleContext(Opt_concurrentlyContext,0); +}; + +RefreshmatviewstmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +RefreshmatviewstmtContext.prototype.opt_with_data = function() { + return this.getTypedRuleContext(Opt_with_dataContext,0); +}; + +RefreshmatviewstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRefreshmatviewstmt(this); + } +}; + +RefreshmatviewstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRefreshmatviewstmt(this); + } +}; + +RefreshmatviewstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRefreshmatviewstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RefreshmatviewstmtContext = RefreshmatviewstmtContext; + +PostgreSQLParser.prototype.refreshmatviewstmt = function() { + + var localctx = new RefreshmatviewstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 276, PostgreSQLParser.RULE_refreshmatviewstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3229; + this.match(PostgreSQLParser.REFRESH); + this.state = 3230; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 3231; + this.match(PostgreSQLParser.VIEW); + this.state = 3232; + this.opt_concurrently(); + this.state = 3233; + this.qualified_name(); + this.state = 3234; + this.opt_with_data(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateseqstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createseqstmt; + return this; +} + +CreateseqstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateseqstmtContext.prototype.constructor = CreateseqstmtContext; + +CreateseqstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateseqstmtContext.prototype.opttemp = function() { + return this.getTypedRuleContext(OpttempContext,0); +}; + +CreateseqstmtContext.prototype.SEQUENCE = function() { + return this.getToken(PostgreSQLParser.SEQUENCE, 0); +}; + +CreateseqstmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +CreateseqstmtContext.prototype.optseqoptlist = function() { + return this.getTypedRuleContext(OptseqoptlistContext,0); +}; + +CreateseqstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +CreateseqstmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +CreateseqstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +CreateseqstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateseqstmt(this); + } +}; + +CreateseqstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateseqstmt(this); + } +}; + +CreateseqstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateseqstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateseqstmtContext = CreateseqstmtContext; + +PostgreSQLParser.prototype.createseqstmt = function() { + + var localctx = new CreateseqstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 278, PostgreSQLParser.RULE_createseqstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3236; + this.match(PostgreSQLParser.CREATE); + this.state = 3237; + this.opttemp(); + this.state = 3238; + this.match(PostgreSQLParser.SEQUENCE); + this.state = 3242; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,129,this._ctx); + if(la_===1) { + this.state = 3239; + this.match(PostgreSQLParser.IF_P); + this.state = 3240; + this.match(PostgreSQLParser.NOT); + this.state = 3241; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 3244; + this.qualified_name(); + this.state = 3245; + this.optseqoptlist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterseqstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterseqstmt; + return this; +} + +AlterseqstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterseqstmtContext.prototype.constructor = AlterseqstmtContext; + +AlterseqstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterseqstmtContext.prototype.SEQUENCE = function() { + return this.getToken(PostgreSQLParser.SEQUENCE, 0); +}; + +AlterseqstmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +AlterseqstmtContext.prototype.seqoptlist = function() { + return this.getTypedRuleContext(SeqoptlistContext,0); +}; + +AlterseqstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +AlterseqstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +AlterseqstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterseqstmt(this); + } +}; + +AlterseqstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterseqstmt(this); + } +}; + +AlterseqstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterseqstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterseqstmtContext = AlterseqstmtContext; + +PostgreSQLParser.prototype.alterseqstmt = function() { + + var localctx = new AlterseqstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 280, PostgreSQLParser.RULE_alterseqstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3247; + this.match(PostgreSQLParser.ALTER); + this.state = 3248; + this.match(PostgreSQLParser.SEQUENCE); + this.state = 3251; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,130,this._ctx); + if(la_===1) { + this.state = 3249; + this.match(PostgreSQLParser.IF_P); + this.state = 3250; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 3253; + this.qualified_name(); + this.state = 3254; + this.seqoptlist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptseqoptlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optseqoptlist; + return this; +} + +OptseqoptlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptseqoptlistContext.prototype.constructor = OptseqoptlistContext; + +OptseqoptlistContext.prototype.seqoptlist = function() { + return this.getTypedRuleContext(SeqoptlistContext,0); +}; + +OptseqoptlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptseqoptlist(this); + } +}; + +OptseqoptlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptseqoptlist(this); + } +}; + +OptseqoptlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptseqoptlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptseqoptlistContext = OptseqoptlistContext; + +PostgreSQLParser.prototype.optseqoptlist = function() { + + var localctx = new OptseqoptlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 282, PostgreSQLParser.RULE_optseqoptlist); + try { + this.state = 3258; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,131,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3256; + this.seqoptlist(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptparenthesizedseqoptlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optparenthesizedseqoptlist; + return this; +} + +OptparenthesizedseqoptlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptparenthesizedseqoptlistContext.prototype.constructor = OptparenthesizedseqoptlistContext; + +OptparenthesizedseqoptlistContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +OptparenthesizedseqoptlistContext.prototype.seqoptlist = function() { + return this.getTypedRuleContext(SeqoptlistContext,0); +}; + +OptparenthesizedseqoptlistContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +OptparenthesizedseqoptlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptparenthesizedseqoptlist(this); + } +}; + +OptparenthesizedseqoptlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptparenthesizedseqoptlist(this); + } +}; + +OptparenthesizedseqoptlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptparenthesizedseqoptlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptparenthesizedseqoptlistContext = OptparenthesizedseqoptlistContext; + +PostgreSQLParser.prototype.optparenthesizedseqoptlist = function() { + + var localctx = new OptparenthesizedseqoptlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 284, PostgreSQLParser.RULE_optparenthesizedseqoptlist); + try { + this.state = 3265; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,132,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3260; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3261; + this.seqoptlist(); + this.state = 3262; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function SeqoptlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_seqoptlist; + return this; +} + +SeqoptlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +SeqoptlistContext.prototype.constructor = SeqoptlistContext; + +SeqoptlistContext.prototype.seqoptelem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(SeqoptelemContext); + } else { + return this.getTypedRuleContext(SeqoptelemContext,i); + } +}; + +SeqoptlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSeqoptlist(this); + } +}; + +SeqoptlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSeqoptlist(this); + } +}; + +SeqoptlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSeqoptlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.SeqoptlistContext = SeqoptlistContext; + +PostgreSQLParser.prototype.seqoptlist = function() { + + var localctx = new SeqoptlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 286, PostgreSQLParser.RULE_seqoptlist); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3268; + this._errHandler.sync(this); + var _alt = 1; + do { + switch (_alt) { + case 1: + this.state = 3267; + this.seqoptelem(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 3270; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,133, this._ctx); + } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER ); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function SeqoptelemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_seqoptelem; + return this; +} + +SeqoptelemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +SeqoptelemContext.prototype.constructor = SeqoptelemContext; + +SeqoptelemContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +SeqoptelemContext.prototype.simpletypename = function() { + return this.getTypedRuleContext(SimpletypenameContext,0); +}; + +SeqoptelemContext.prototype.CACHE = function() { + return this.getToken(PostgreSQLParser.CACHE, 0); +}; + +SeqoptelemContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +SeqoptelemContext.prototype.CYCLE = function() { + return this.getToken(PostgreSQLParser.CYCLE, 0); +}; + +SeqoptelemContext.prototype.INCREMENT = function() { + return this.getToken(PostgreSQLParser.INCREMENT, 0); +}; + +SeqoptelemContext.prototype.opt_by = function() { + return this.getTypedRuleContext(Opt_byContext,0); +}; + +SeqoptelemContext.prototype.MAXVALUE = function() { + return this.getToken(PostgreSQLParser.MAXVALUE, 0); +}; + +SeqoptelemContext.prototype.MINVALUE = function() { + return this.getToken(PostgreSQLParser.MINVALUE, 0); +}; + +SeqoptelemContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +SeqoptelemContext.prototype.OWNED = function() { + return this.getToken(PostgreSQLParser.OWNED, 0); +}; + +SeqoptelemContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +SeqoptelemContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +SeqoptelemContext.prototype.SEQUENCE = function() { + return this.getToken(PostgreSQLParser.SEQUENCE, 0); +}; + +SeqoptelemContext.prototype.NAME_P = function() { + return this.getToken(PostgreSQLParser.NAME_P, 0); +}; + +SeqoptelemContext.prototype.START = function() { + return this.getToken(PostgreSQLParser.START, 0); +}; + +SeqoptelemContext.prototype.opt_with = function() { + return this.getTypedRuleContext(Opt_withContext,0); +}; + +SeqoptelemContext.prototype.RESTART = function() { + return this.getToken(PostgreSQLParser.RESTART, 0); +}; + +SeqoptelemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSeqoptelem(this); + } +}; + +SeqoptelemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSeqoptelem(this); + } +}; + +SeqoptelemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSeqoptelem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.SeqoptelemContext = SeqoptelemContext; + +PostgreSQLParser.prototype.seqoptelem = function() { + + var localctx = new SeqoptelemContext(this, this._ctx, this.state); + this.enterRule(localctx, 288, PostgreSQLParser.RULE_seqoptelem); + var _la = 0; // Token type + try { + this.state = 3302; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AS: + this.enterOuterAlt(localctx, 1); + this.state = 3272; + this.match(PostgreSQLParser.AS); + this.state = 3273; + this.simpletypename(); + break; + case PostgreSQLParser.CACHE: + this.enterOuterAlt(localctx, 2); + this.state = 3274; + this.match(PostgreSQLParser.CACHE); + this.state = 3275; + this.numericonly(); + break; + case PostgreSQLParser.CYCLE: + this.enterOuterAlt(localctx, 3); + this.state = 3276; + this.match(PostgreSQLParser.CYCLE); + break; + case PostgreSQLParser.INCREMENT: + this.enterOuterAlt(localctx, 4); + this.state = 3277; + this.match(PostgreSQLParser.INCREMENT); + this.state = 3278; + this.opt_by(); + this.state = 3279; + this.numericonly(); + break; + case PostgreSQLParser.MAXVALUE: + this.enterOuterAlt(localctx, 5); + this.state = 3281; + this.match(PostgreSQLParser.MAXVALUE); + this.state = 3282; + this.numericonly(); + break; + case PostgreSQLParser.MINVALUE: + this.enterOuterAlt(localctx, 6); + this.state = 3283; + this.match(PostgreSQLParser.MINVALUE); + this.state = 3284; + this.numericonly(); + break; + case PostgreSQLParser.NO: + this.enterOuterAlt(localctx, 7); + this.state = 3285; + this.match(PostgreSQLParser.NO); + this.state = 3286; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.CYCLE || _la===PostgreSQLParser.MAXVALUE || _la===PostgreSQLParser.MINVALUE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + case PostgreSQLParser.OWNED: + this.enterOuterAlt(localctx, 8); + this.state = 3287; + this.match(PostgreSQLParser.OWNED); + this.state = 3288; + this.match(PostgreSQLParser.BY); + this.state = 3289; + this.any_name(); + break; + case PostgreSQLParser.SEQUENCE: + this.enterOuterAlt(localctx, 9); + this.state = 3290; + this.match(PostgreSQLParser.SEQUENCE); + this.state = 3291; + this.match(PostgreSQLParser.NAME_P); + this.state = 3292; + this.any_name(); + break; + case PostgreSQLParser.START: + this.enterOuterAlt(localctx, 10); + this.state = 3293; + this.match(PostgreSQLParser.START); + this.state = 3294; + this.opt_with(); + this.state = 3295; + this.numericonly(); + break; + case PostgreSQLParser.RESTART: + this.enterOuterAlt(localctx, 11); + this.state = 3297; + this.match(PostgreSQLParser.RESTART); + this.state = 3298; + this.opt_with(); + this.state = 3300; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.PLUS || _la===PostgreSQLParser.MINUS || _la===PostgreSQLParser.Integral || _la===PostgreSQLParser.Numeric) { + this.state = 3299; + this.numericonly(); + } + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_byContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_by; + return this; +} + +Opt_byContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_byContext.prototype.constructor = Opt_byContext; + +Opt_byContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Opt_byContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_by(this); + } +}; + +Opt_byContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_by(this); + } +}; + +Opt_byContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_by(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_byContext = Opt_byContext; + +PostgreSQLParser.prototype.opt_by = function() { + + var localctx = new Opt_byContext(this, this._ctx, this.state); + this.enterRule(localctx, 290, PostgreSQLParser.RULE_opt_by); + try { + this.state = 3306; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.BY: + this.enterOuterAlt(localctx, 1); + this.state = 3304; + this.match(PostgreSQLParser.BY); + break; + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function NumericonlyContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_numericonly; + return this; +} + +NumericonlyContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +NumericonlyContext.prototype.constructor = NumericonlyContext; + +NumericonlyContext.prototype.fconst = function() { + return this.getTypedRuleContext(FconstContext,0); +}; + +NumericonlyContext.prototype.PLUS = function() { + return this.getToken(PostgreSQLParser.PLUS, 0); +}; + +NumericonlyContext.prototype.MINUS = function() { + return this.getToken(PostgreSQLParser.MINUS, 0); +}; + +NumericonlyContext.prototype.signediconst = function() { + return this.getTypedRuleContext(SignediconstContext,0); +}; + +NumericonlyContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterNumericonly(this); + } +}; + +NumericonlyContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitNumericonly(this); + } +}; + +NumericonlyContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitNumericonly(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.NumericonlyContext = NumericonlyContext; + +PostgreSQLParser.prototype.numericonly = function() { + + var localctx = new NumericonlyContext(this, this._ctx, this.state); + this.enterRule(localctx, 292, PostgreSQLParser.RULE_numericonly); + try { + this.state = 3314; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,137,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3308; + this.fconst(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3309; + this.match(PostgreSQLParser.PLUS); + this.state = 3310; + this.fconst(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 3311; + this.match(PostgreSQLParser.MINUS); + this.state = 3312; + this.fconst(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 3313; + this.signediconst(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Numericonly_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_numericonly_list; + return this; +} + +Numericonly_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Numericonly_listContext.prototype.constructor = Numericonly_listContext; + +Numericonly_listContext.prototype.numericonly = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(NumericonlyContext); + } else { + return this.getTypedRuleContext(NumericonlyContext,i); + } +}; + +Numericonly_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Numericonly_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterNumericonly_list(this); + } +}; + +Numericonly_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitNumericonly_list(this); + } +}; + +Numericonly_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitNumericonly_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Numericonly_listContext = Numericonly_listContext; + +PostgreSQLParser.prototype.numericonly_list = function() { + + var localctx = new Numericonly_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 294, PostgreSQLParser.RULE_numericonly_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3316; + this.numericonly(); + this.state = 3321; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 3317; + this.match(PostgreSQLParser.COMMA); + this.state = 3318; + this.numericonly(); + this.state = 3323; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateplangstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createplangstmt; + return this; +} + +CreateplangstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateplangstmtContext.prototype.constructor = CreateplangstmtContext; + +CreateplangstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateplangstmtContext.prototype.opt_or_replace = function() { + return this.getTypedRuleContext(Opt_or_replaceContext,0); +}; + +CreateplangstmtContext.prototype.opt_trusted = function() { + return this.getTypedRuleContext(Opt_trustedContext,0); +}; + +CreateplangstmtContext.prototype.opt_procedural = function() { + return this.getTypedRuleContext(Opt_proceduralContext,0); +}; + +CreateplangstmtContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +CreateplangstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreateplangstmtContext.prototype.HANDLER = function() { + return this.getToken(PostgreSQLParser.HANDLER, 0); +}; + +CreateplangstmtContext.prototype.handler_name = function() { + return this.getTypedRuleContext(Handler_nameContext,0); +}; + +CreateplangstmtContext.prototype.opt_inline_handler = function() { + return this.getTypedRuleContext(Opt_inline_handlerContext,0); +}; + +CreateplangstmtContext.prototype.opt_validator = function() { + return this.getTypedRuleContext(Opt_validatorContext,0); +}; + +CreateplangstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateplangstmt(this); + } +}; + +CreateplangstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateplangstmt(this); + } +}; + +CreateplangstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateplangstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateplangstmtContext = CreateplangstmtContext; + +PostgreSQLParser.prototype.createplangstmt = function() { + + var localctx = new CreateplangstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 296, PostgreSQLParser.RULE_createplangstmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3324; + this.match(PostgreSQLParser.CREATE); + this.state = 3325; + this.opt_or_replace(); + this.state = 3326; + this.opt_trusted(); + this.state = 3327; + this.opt_procedural(); + this.state = 3328; + this.match(PostgreSQLParser.LANGUAGE); + this.state = 3329; + this.name(); + this.state = 3335; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.HANDLER) { + this.state = 3330; + this.match(PostgreSQLParser.HANDLER); + this.state = 3331; + this.handler_name(); + this.state = 3332; + this.opt_inline_handler(); + this.state = 3333; + this.opt_validator(); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_trustedContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_trusted; + return this; +} + +Opt_trustedContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_trustedContext.prototype.constructor = Opt_trustedContext; + +Opt_trustedContext.prototype.TRUSTED = function() { + return this.getToken(PostgreSQLParser.TRUSTED, 0); +}; + +Opt_trustedContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_trusted(this); + } +}; + +Opt_trustedContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_trusted(this); + } +}; + +Opt_trustedContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_trusted(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_trustedContext = Opt_trustedContext; + +PostgreSQLParser.prototype.opt_trusted = function() { + + var localctx = new Opt_trustedContext(this, this._ctx, this.state); + this.enterRule(localctx, 298, PostgreSQLParser.RULE_opt_trusted); + try { + this.state = 3339; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.TRUSTED: + this.enterOuterAlt(localctx, 1); + this.state = 3337; + this.match(PostgreSQLParser.TRUSTED); + break; + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.PROCEDURAL: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Handler_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_handler_name; + return this; +} + +Handler_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Handler_nameContext.prototype.constructor = Handler_nameContext; + +Handler_nameContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Handler_nameContext.prototype.attrs = function() { + return this.getTypedRuleContext(AttrsContext,0); +}; + +Handler_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterHandler_name(this); + } +}; + +Handler_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitHandler_name(this); + } +}; + +Handler_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitHandler_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Handler_nameContext = Handler_nameContext; + +PostgreSQLParser.prototype.handler_name = function() { + + var localctx = new Handler_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 300, PostgreSQLParser.RULE_handler_name); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3341; + this.name(); + this.state = 3343; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.DOT) { + this.state = 3342; + this.attrs(); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_inline_handlerContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_inline_handler; + return this; +} + +Opt_inline_handlerContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_inline_handlerContext.prototype.constructor = Opt_inline_handlerContext; + +Opt_inline_handlerContext.prototype.INLINE_P = function() { + return this.getToken(PostgreSQLParser.INLINE_P, 0); +}; + +Opt_inline_handlerContext.prototype.handler_name = function() { + return this.getTypedRuleContext(Handler_nameContext,0); +}; + +Opt_inline_handlerContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_inline_handler(this); + } +}; + +Opt_inline_handlerContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_inline_handler(this); + } +}; + +Opt_inline_handlerContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_inline_handler(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_inline_handlerContext = Opt_inline_handlerContext; + +PostgreSQLParser.prototype.opt_inline_handler = function() { + + var localctx = new Opt_inline_handlerContext(this, this._ctx, this.state); + this.enterRule(localctx, 302, PostgreSQLParser.RULE_opt_inline_handler); + try { + this.state = 3348; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.INLINE_P: + this.enterOuterAlt(localctx, 1); + this.state = 3345; + this.match(PostgreSQLParser.INLINE_P); + this.state = 3346; + this.handler_name(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Validator_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_validator_clause; + return this; +} + +Validator_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Validator_clauseContext.prototype.constructor = Validator_clauseContext; + +Validator_clauseContext.prototype.VALIDATOR = function() { + return this.getToken(PostgreSQLParser.VALIDATOR, 0); +}; + +Validator_clauseContext.prototype.handler_name = function() { + return this.getTypedRuleContext(Handler_nameContext,0); +}; + +Validator_clauseContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Validator_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterValidator_clause(this); + } +}; + +Validator_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitValidator_clause(this); + } +}; + +Validator_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitValidator_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Validator_clauseContext = Validator_clauseContext; + +PostgreSQLParser.prototype.validator_clause = function() { + + var localctx = new Validator_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 304, PostgreSQLParser.RULE_validator_clause); + try { + this.state = 3354; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.VALIDATOR: + this.enterOuterAlt(localctx, 1); + this.state = 3350; + this.match(PostgreSQLParser.VALIDATOR); + this.state = 3351; + this.handler_name(); + break; + case PostgreSQLParser.NO: + this.enterOuterAlt(localctx, 2); + this.state = 3352; + this.match(PostgreSQLParser.NO); + this.state = 3353; + this.match(PostgreSQLParser.VALIDATOR); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_validatorContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_validator; + return this; +} + +Opt_validatorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_validatorContext.prototype.constructor = Opt_validatorContext; + +Opt_validatorContext.prototype.validator_clause = function() { + return this.getTypedRuleContext(Validator_clauseContext,0); +}; + +Opt_validatorContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_validator(this); + } +}; + +Opt_validatorContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_validator(this); + } +}; + +Opt_validatorContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_validator(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_validatorContext = Opt_validatorContext; + +PostgreSQLParser.prototype.opt_validator = function() { + + var localctx = new Opt_validatorContext(this, this._ctx, this.state); + this.enterRule(localctx, 306, PostgreSQLParser.RULE_opt_validator); + try { + this.state = 3358; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NO: + case PostgreSQLParser.VALIDATOR: + this.enterOuterAlt(localctx, 1); + this.state = 3356; + this.validator_clause(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_proceduralContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_procedural; + return this; +} + +Opt_proceduralContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_proceduralContext.prototype.constructor = Opt_proceduralContext; + +Opt_proceduralContext.prototype.PROCEDURAL = function() { + return this.getToken(PostgreSQLParser.PROCEDURAL, 0); +}; + +Opt_proceduralContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_procedural(this); + } +}; + +Opt_proceduralContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_procedural(this); + } +}; + +Opt_proceduralContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_procedural(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_proceduralContext = Opt_proceduralContext; + +PostgreSQLParser.prototype.opt_procedural = function() { + + var localctx = new Opt_proceduralContext(this, this._ctx, this.state); + this.enterRule(localctx, 308, PostgreSQLParser.RULE_opt_procedural); + try { + this.state = 3362; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.PROCEDURAL: + this.enterOuterAlt(localctx, 1); + this.state = 3360; + this.match(PostgreSQLParser.PROCEDURAL); + break; + case PostgreSQLParser.LANGUAGE: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatetablespacestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createtablespacestmt; + return this; +} + +CreatetablespacestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatetablespacestmtContext.prototype.constructor = CreatetablespacestmtContext; + +CreatetablespacestmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatetablespacestmtContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +CreatetablespacestmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreatetablespacestmtContext.prototype.opttablespaceowner = function() { + return this.getTypedRuleContext(OpttablespaceownerContext,0); +}; + +CreatetablespacestmtContext.prototype.LOCATION = function() { + return this.getToken(PostgreSQLParser.LOCATION, 0); +}; + +CreatetablespacestmtContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +CreatetablespacestmtContext.prototype.opt_reloptions = function() { + return this.getTypedRuleContext(Opt_reloptionsContext,0); +}; + +CreatetablespacestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatetablespacestmt(this); + } +}; + +CreatetablespacestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatetablespacestmt(this); + } +}; + +CreatetablespacestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatetablespacestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatetablespacestmtContext = CreatetablespacestmtContext; + +PostgreSQLParser.prototype.createtablespacestmt = function() { + + var localctx = new CreatetablespacestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 310, PostgreSQLParser.RULE_createtablespacestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3364; + this.match(PostgreSQLParser.CREATE); + this.state = 3365; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 3366; + this.name(); + this.state = 3367; + this.opttablespaceowner(); + this.state = 3368; + this.match(PostgreSQLParser.LOCATION); + this.state = 3369; + this.sconst(); + this.state = 3370; + this.opt_reloptions(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OpttablespaceownerContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opttablespaceowner; + return this; +} + +OpttablespaceownerContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OpttablespaceownerContext.prototype.constructor = OpttablespaceownerContext; + +OpttablespaceownerContext.prototype.OWNER = function() { + return this.getToken(PostgreSQLParser.OWNER, 0); +}; + +OpttablespaceownerContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +OpttablespaceownerContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpttablespaceowner(this); + } +}; + +OpttablespaceownerContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpttablespaceowner(this); + } +}; + +OpttablespaceownerContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpttablespaceowner(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OpttablespaceownerContext = OpttablespaceownerContext; + +PostgreSQLParser.prototype.opttablespaceowner = function() { + + var localctx = new OpttablespaceownerContext(this, this._ctx, this.state); + this.enterRule(localctx, 312, PostgreSQLParser.RULE_opttablespaceowner); + try { + this.state = 3375; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OWNER: + this.enterOuterAlt(localctx, 1); + this.state = 3372; + this.match(PostgreSQLParser.OWNER); + this.state = 3373; + this.rolespec(); + break; + case PostgreSQLParser.LOCATION: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DroptablespacestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_droptablespacestmt; + return this; +} + +DroptablespacestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DroptablespacestmtContext.prototype.constructor = DroptablespacestmtContext; + +DroptablespacestmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DroptablespacestmtContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +DroptablespacestmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +DroptablespacestmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +DroptablespacestmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +DroptablespacestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDroptablespacestmt(this); + } +}; + +DroptablespacestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDroptablespacestmt(this); + } +}; + +DroptablespacestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDroptablespacestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DroptablespacestmtContext = DroptablespacestmtContext; + +PostgreSQLParser.prototype.droptablespacestmt = function() { + + var localctx = new DroptablespacestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 314, PostgreSQLParser.RULE_droptablespacestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3377; + this.match(PostgreSQLParser.DROP); + this.state = 3378; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 3381; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,147,this._ctx); + if(la_===1) { + this.state = 3379; + this.match(PostgreSQLParser.IF_P); + this.state = 3380; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 3383; + this.name(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateextensionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createextensionstmt; + return this; +} + +CreateextensionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateextensionstmtContext.prototype.constructor = CreateextensionstmtContext; + +CreateextensionstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateextensionstmtContext.prototype.EXTENSION = function() { + return this.getToken(PostgreSQLParser.EXTENSION, 0); +}; + +CreateextensionstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreateextensionstmtContext.prototype.opt_with = function() { + return this.getTypedRuleContext(Opt_withContext,0); +}; + +CreateextensionstmtContext.prototype.create_extension_opt_list = function() { + return this.getTypedRuleContext(Create_extension_opt_listContext,0); +}; + +CreateextensionstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +CreateextensionstmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +CreateextensionstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +CreateextensionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateextensionstmt(this); + } +}; + +CreateextensionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateextensionstmt(this); + } +}; + +CreateextensionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateextensionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateextensionstmtContext = CreateextensionstmtContext; + +PostgreSQLParser.prototype.createextensionstmt = function() { + + var localctx = new CreateextensionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 316, PostgreSQLParser.RULE_createextensionstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3385; + this.match(PostgreSQLParser.CREATE); + this.state = 3386; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3390; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,148,this._ctx); + if(la_===1) { + this.state = 3387; + this.match(PostgreSQLParser.IF_P); + this.state = 3388; + this.match(PostgreSQLParser.NOT); + this.state = 3389; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 3392; + this.name(); + this.state = 3393; + this.opt_with(); + this.state = 3394; + this.create_extension_opt_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Create_extension_opt_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_create_extension_opt_list; + return this; +} + +Create_extension_opt_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Create_extension_opt_listContext.prototype.constructor = Create_extension_opt_listContext; + +Create_extension_opt_listContext.prototype.create_extension_opt_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Create_extension_opt_itemContext); + } else { + return this.getTypedRuleContext(Create_extension_opt_itemContext,i); + } +}; + +Create_extension_opt_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreate_extension_opt_list(this); + } +}; + +Create_extension_opt_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreate_extension_opt_list(this); + } +}; + +Create_extension_opt_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreate_extension_opt_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Create_extension_opt_listContext = Create_extension_opt_listContext; + +PostgreSQLParser.prototype.create_extension_opt_list = function() { + + var localctx = new Create_extension_opt_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 318, PostgreSQLParser.RULE_create_extension_opt_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3399; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.FROM || _la===PostgreSQLParser.CASCADE || _la===PostgreSQLParser.SCHEMA || _la===PostgreSQLParser.VERSION_P) { + this.state = 3396; + this.create_extension_opt_item(); + this.state = 3401; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Create_extension_opt_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_create_extension_opt_item; + return this; +} + +Create_extension_opt_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Create_extension_opt_itemContext.prototype.constructor = Create_extension_opt_itemContext; + +Create_extension_opt_itemContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +Create_extension_opt_itemContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Create_extension_opt_itemContext.prototype.VERSION_P = function() { + return this.getToken(PostgreSQLParser.VERSION_P, 0); +}; + +Create_extension_opt_itemContext.prototype.nonreservedword_or_sconst = function() { + return this.getTypedRuleContext(Nonreservedword_or_sconstContext,0); +}; + +Create_extension_opt_itemContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Create_extension_opt_itemContext.prototype.CASCADE = function() { + return this.getToken(PostgreSQLParser.CASCADE, 0); +}; + +Create_extension_opt_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreate_extension_opt_item(this); + } +}; + +Create_extension_opt_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreate_extension_opt_item(this); + } +}; + +Create_extension_opt_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreate_extension_opt_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Create_extension_opt_itemContext = Create_extension_opt_itemContext; + +PostgreSQLParser.prototype.create_extension_opt_item = function() { + + var localctx = new Create_extension_opt_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 320, PostgreSQLParser.RULE_create_extension_opt_item); + try { + this.state = 3409; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SCHEMA: + this.enterOuterAlt(localctx, 1); + this.state = 3402; + this.match(PostgreSQLParser.SCHEMA); + this.state = 3403; + this.name(); + break; + case PostgreSQLParser.VERSION_P: + this.enterOuterAlt(localctx, 2); + this.state = 3404; + this.match(PostgreSQLParser.VERSION_P); + this.state = 3405; + this.nonreservedword_or_sconst(); + break; + case PostgreSQLParser.FROM: + this.enterOuterAlt(localctx, 3); + this.state = 3406; + this.match(PostgreSQLParser.FROM); + this.state = 3407; + this.nonreservedword_or_sconst(); + break; + case PostgreSQLParser.CASCADE: + this.enterOuterAlt(localctx, 4); + this.state = 3408; + this.match(PostgreSQLParser.CASCADE); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterextensionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterextensionstmt; + return this; +} + +AlterextensionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterextensionstmtContext.prototype.constructor = AlterextensionstmtContext; + +AlterextensionstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterextensionstmtContext.prototype.EXTENSION = function() { + return this.getToken(PostgreSQLParser.EXTENSION, 0); +}; + +AlterextensionstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AlterextensionstmtContext.prototype.UPDATE = function() { + return this.getToken(PostgreSQLParser.UPDATE, 0); +}; + +AlterextensionstmtContext.prototype.alter_extension_opt_list = function() { + return this.getTypedRuleContext(Alter_extension_opt_listContext,0); +}; + +AlterextensionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterextensionstmt(this); + } +}; + +AlterextensionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterextensionstmt(this); + } +}; + +AlterextensionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterextensionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterextensionstmtContext = AlterextensionstmtContext; + +PostgreSQLParser.prototype.alterextensionstmt = function() { + + var localctx = new AlterextensionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 322, PostgreSQLParser.RULE_alterextensionstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3411; + this.match(PostgreSQLParser.ALTER); + this.state = 3412; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3413; + this.name(); + this.state = 3414; + this.match(PostgreSQLParser.UPDATE); + this.state = 3415; + this.alter_extension_opt_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_extension_opt_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_extension_opt_list; + return this; +} + +Alter_extension_opt_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_extension_opt_listContext.prototype.constructor = Alter_extension_opt_listContext; + +Alter_extension_opt_listContext.prototype.alter_extension_opt_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Alter_extension_opt_itemContext); + } else { + return this.getTypedRuleContext(Alter_extension_opt_itemContext,i); + } +}; + +Alter_extension_opt_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_extension_opt_list(this); + } +}; + +Alter_extension_opt_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_extension_opt_list(this); + } +}; + +Alter_extension_opt_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_extension_opt_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_extension_opt_listContext = Alter_extension_opt_listContext; + +PostgreSQLParser.prototype.alter_extension_opt_list = function() { + + var localctx = new Alter_extension_opt_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 324, PostgreSQLParser.RULE_alter_extension_opt_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3420; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.TO) { + this.state = 3417; + this.alter_extension_opt_item(); + this.state = 3422; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_extension_opt_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_extension_opt_item; + return this; +} + +Alter_extension_opt_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_extension_opt_itemContext.prototype.constructor = Alter_extension_opt_itemContext; + +Alter_extension_opt_itemContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +Alter_extension_opt_itemContext.prototype.nonreservedword_or_sconst = function() { + return this.getTypedRuleContext(Nonreservedword_or_sconstContext,0); +}; + +Alter_extension_opt_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_extension_opt_item(this); + } +}; + +Alter_extension_opt_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_extension_opt_item(this); + } +}; + +Alter_extension_opt_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_extension_opt_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_extension_opt_itemContext = Alter_extension_opt_itemContext; + +PostgreSQLParser.prototype.alter_extension_opt_item = function() { + + var localctx = new Alter_extension_opt_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 326, PostgreSQLParser.RULE_alter_extension_opt_item); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3423; + this.match(PostgreSQLParser.TO); + this.state = 3424; + this.nonreservedword_or_sconst(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterextensioncontentsstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterextensioncontentsstmt; + return this; +} + +AlterextensioncontentsstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterextensioncontentsstmtContext.prototype.constructor = AlterextensioncontentsstmtContext; + +AlterextensioncontentsstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterextensioncontentsstmtContext.prototype.EXTENSION = function() { + return this.getToken(PostgreSQLParser.EXTENSION, 0); +}; + +AlterextensioncontentsstmtContext.prototype.name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(NameContext); + } else { + return this.getTypedRuleContext(NameContext,i); + } +}; + +AlterextensioncontentsstmtContext.prototype.add_drop = function() { + return this.getTypedRuleContext(Add_dropContext,0); +}; + +AlterextensioncontentsstmtContext.prototype.object_type_name = function() { + return this.getTypedRuleContext(Object_type_nameContext,0); +}; + +AlterextensioncontentsstmtContext.prototype.object_type_any_name = function() { + return this.getTypedRuleContext(Object_type_any_nameContext,0); +}; + +AlterextensioncontentsstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AlterextensioncontentsstmtContext.prototype.AGGREGATE = function() { + return this.getToken(PostgreSQLParser.AGGREGATE, 0); +}; + +AlterextensioncontentsstmtContext.prototype.aggregate_with_argtypes = function() { + return this.getTypedRuleContext(Aggregate_with_argtypesContext,0); +}; + +AlterextensioncontentsstmtContext.prototype.CAST = function() { + return this.getToken(PostgreSQLParser.CAST, 0); +}; + +AlterextensioncontentsstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +AlterextensioncontentsstmtContext.prototype.typename = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TypenameContext); + } else { + return this.getTypedRuleContext(TypenameContext,i); + } +}; + +AlterextensioncontentsstmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +AlterextensioncontentsstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +AlterextensioncontentsstmtContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +AlterextensioncontentsstmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +AlterextensioncontentsstmtContext.prototype.function_with_argtypes = function() { + return this.getTypedRuleContext(Function_with_argtypesContext,0); +}; + +AlterextensioncontentsstmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +AlterextensioncontentsstmtContext.prototype.operator_with_argtypes = function() { + return this.getTypedRuleContext(Operator_with_argtypesContext,0); +}; + +AlterextensioncontentsstmtContext.prototype.CLASS = function() { + return this.getToken(PostgreSQLParser.CLASS, 0); +}; + +AlterextensioncontentsstmtContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +AlterextensioncontentsstmtContext.prototype.FAMILY = function() { + return this.getToken(PostgreSQLParser.FAMILY, 0); +}; + +AlterextensioncontentsstmtContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +AlterextensioncontentsstmtContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +AlterextensioncontentsstmtContext.prototype.TRANSFORM = function() { + return this.getToken(PostgreSQLParser.TRANSFORM, 0); +}; + +AlterextensioncontentsstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +AlterextensioncontentsstmtContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +AlterextensioncontentsstmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +AlterextensioncontentsstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterextensioncontentsstmt(this); + } +}; + +AlterextensioncontentsstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterextensioncontentsstmt(this); + } +}; + +AlterextensioncontentsstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterextensioncontentsstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterextensioncontentsstmtContext = AlterextensioncontentsstmtContext; + +PostgreSQLParser.prototype.alterextensioncontentsstmt = function() { + + var localctx = new AlterextensioncontentsstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 328, PostgreSQLParser.RULE_alterextensioncontentsstmt); + try { + this.state = 3530; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,152,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3426; + this.match(PostgreSQLParser.ALTER); + this.state = 3427; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3428; + this.name(); + this.state = 3429; + this.add_drop(); + this.state = 3430; + this.object_type_name(); + this.state = 3431; + this.name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3433; + this.match(PostgreSQLParser.ALTER); + this.state = 3434; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3435; + this.name(); + this.state = 3436; + this.add_drop(); + this.state = 3437; + this.object_type_any_name(); + this.state = 3438; + this.any_name(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 3440; + this.match(PostgreSQLParser.ALTER); + this.state = 3441; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3442; + this.name(); + this.state = 3443; + this.add_drop(); + this.state = 3444; + this.match(PostgreSQLParser.AGGREGATE); + this.state = 3445; + this.aggregate_with_argtypes(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 3447; + this.match(PostgreSQLParser.ALTER); + this.state = 3448; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3449; + this.name(); + this.state = 3450; + this.add_drop(); + this.state = 3451; + this.match(PostgreSQLParser.CAST); + this.state = 3452; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3453; + this.typename(); + this.state = 3454; + this.match(PostgreSQLParser.AS); + this.state = 3455; + this.typename(); + this.state = 3456; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 3458; + this.match(PostgreSQLParser.ALTER); + this.state = 3459; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3460; + this.name(); + this.state = 3461; + this.add_drop(); + this.state = 3462; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 3463; + this.typename(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 3465; + this.match(PostgreSQLParser.ALTER); + this.state = 3466; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3467; + this.name(); + this.state = 3468; + this.add_drop(); + this.state = 3469; + this.match(PostgreSQLParser.FUNCTION); + this.state = 3470; + this.function_with_argtypes(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 3472; + this.match(PostgreSQLParser.ALTER); + this.state = 3473; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3474; + this.name(); + this.state = 3475; + this.add_drop(); + this.state = 3476; + this.match(PostgreSQLParser.OPERATOR); + this.state = 3477; + this.operator_with_argtypes(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 3479; + this.match(PostgreSQLParser.ALTER); + this.state = 3480; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3481; + this.name(); + this.state = 3482; + this.add_drop(); + this.state = 3483; + this.match(PostgreSQLParser.OPERATOR); + this.state = 3484; + this.match(PostgreSQLParser.CLASS); + this.state = 3485; + this.any_name(); + this.state = 3486; + this.match(PostgreSQLParser.USING); + this.state = 3487; + this.name(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 3489; + this.match(PostgreSQLParser.ALTER); + this.state = 3490; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3491; + this.name(); + this.state = 3492; + this.add_drop(); + this.state = 3493; + this.match(PostgreSQLParser.OPERATOR); + this.state = 3494; + this.match(PostgreSQLParser.FAMILY); + this.state = 3495; + this.any_name(); + this.state = 3496; + this.match(PostgreSQLParser.USING); + this.state = 3497; + this.name(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 3499; + this.match(PostgreSQLParser.ALTER); + this.state = 3500; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3501; + this.name(); + this.state = 3502; + this.add_drop(); + this.state = 3503; + this.match(PostgreSQLParser.PROCEDURE); + this.state = 3504; + this.function_with_argtypes(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 3506; + this.match(PostgreSQLParser.ALTER); + this.state = 3507; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3508; + this.name(); + this.state = 3509; + this.add_drop(); + this.state = 3510; + this.match(PostgreSQLParser.ROUTINE); + this.state = 3511; + this.function_with_argtypes(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 3513; + this.match(PostgreSQLParser.ALTER); + this.state = 3514; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3515; + this.name(); + this.state = 3516; + this.add_drop(); + this.state = 3517; + this.match(PostgreSQLParser.TRANSFORM); + this.state = 3518; + this.match(PostgreSQLParser.FOR); + this.state = 3519; + this.typename(); + this.state = 3520; + this.match(PostgreSQLParser.LANGUAGE); + this.state = 3521; + this.name(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 3523; + this.match(PostgreSQLParser.ALTER); + this.state = 3524; + this.match(PostgreSQLParser.EXTENSION); + this.state = 3525; + this.name(); + this.state = 3526; + this.add_drop(); + this.state = 3527; + this.match(PostgreSQLParser.TYPE_P); + this.state = 3528; + this.typename(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatefdwstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createfdwstmt; + return this; +} + +CreatefdwstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatefdwstmtContext.prototype.constructor = CreatefdwstmtContext; + +CreatefdwstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatefdwstmtContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +CreatefdwstmtContext.prototype.DATA_P = function() { + return this.getToken(PostgreSQLParser.DATA_P, 0); +}; + +CreatefdwstmtContext.prototype.WRAPPER = function() { + return this.getToken(PostgreSQLParser.WRAPPER, 0); +}; + +CreatefdwstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreatefdwstmtContext.prototype.opt_fdw_options = function() { + return this.getTypedRuleContext(Opt_fdw_optionsContext,0); +}; + +CreatefdwstmtContext.prototype.create_generic_options = function() { + return this.getTypedRuleContext(Create_generic_optionsContext,0); +}; + +CreatefdwstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatefdwstmt(this); + } +}; + +CreatefdwstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatefdwstmt(this); + } +}; + +CreatefdwstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatefdwstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatefdwstmtContext = CreatefdwstmtContext; + +PostgreSQLParser.prototype.createfdwstmt = function() { + + var localctx = new CreatefdwstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 330, PostgreSQLParser.RULE_createfdwstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3532; + this.match(PostgreSQLParser.CREATE); + this.state = 3533; + this.match(PostgreSQLParser.FOREIGN); + this.state = 3534; + this.match(PostgreSQLParser.DATA_P); + this.state = 3535; + this.match(PostgreSQLParser.WRAPPER); + this.state = 3536; + this.name(); + this.state = 3537; + this.opt_fdw_options(); + this.state = 3538; + this.create_generic_options(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Fdw_optionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_fdw_option; + return this; +} + +Fdw_optionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Fdw_optionContext.prototype.constructor = Fdw_optionContext; + +Fdw_optionContext.prototype.HANDLER = function() { + return this.getToken(PostgreSQLParser.HANDLER, 0); +}; + +Fdw_optionContext.prototype.handler_name = function() { + return this.getTypedRuleContext(Handler_nameContext,0); +}; + +Fdw_optionContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Fdw_optionContext.prototype.VALIDATOR = function() { + return this.getToken(PostgreSQLParser.VALIDATOR, 0); +}; + +Fdw_optionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFdw_option(this); + } +}; + +Fdw_optionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFdw_option(this); + } +}; + +Fdw_optionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFdw_option(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Fdw_optionContext = Fdw_optionContext; + +PostgreSQLParser.prototype.fdw_option = function() { + + var localctx = new Fdw_optionContext(this, this._ctx, this.state); + this.enterRule(localctx, 332, PostgreSQLParser.RULE_fdw_option); + try { + this.state = 3548; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,153,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3540; + this.match(PostgreSQLParser.HANDLER); + this.state = 3541; + this.handler_name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3542; + this.match(PostgreSQLParser.NO); + this.state = 3543; + this.match(PostgreSQLParser.HANDLER); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 3544; + this.match(PostgreSQLParser.VALIDATOR); + this.state = 3545; + this.handler_name(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 3546; + this.match(PostgreSQLParser.NO); + this.state = 3547; + this.match(PostgreSQLParser.VALIDATOR); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Fdw_optionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_fdw_options; + return this; +} + +Fdw_optionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Fdw_optionsContext.prototype.constructor = Fdw_optionsContext; + +Fdw_optionsContext.prototype.fdw_option = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Fdw_optionContext); + } else { + return this.getTypedRuleContext(Fdw_optionContext,i); + } +}; + +Fdw_optionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFdw_options(this); + } +}; + +Fdw_optionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFdw_options(this); + } +}; + +Fdw_optionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFdw_options(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Fdw_optionsContext = Fdw_optionsContext; + +PostgreSQLParser.prototype.fdw_options = function() { + + var localctx = new Fdw_optionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 334, PostgreSQLParser.RULE_fdw_options); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3551; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + this.state = 3550; + this.fdw_option(); + this.state = 3553; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while(_la===PostgreSQLParser.HANDLER || _la===PostgreSQLParser.NO || _la===PostgreSQLParser.VALIDATOR); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_fdw_optionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_fdw_options; + return this; +} + +Opt_fdw_optionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_fdw_optionsContext.prototype.constructor = Opt_fdw_optionsContext; + +Opt_fdw_optionsContext.prototype.fdw_options = function() { + return this.getTypedRuleContext(Fdw_optionsContext,0); +}; + +Opt_fdw_optionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_fdw_options(this); + } +}; + +Opt_fdw_optionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_fdw_options(this); + } +}; + +Opt_fdw_optionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_fdw_options(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_fdw_optionsContext = Opt_fdw_optionsContext; + +PostgreSQLParser.prototype.opt_fdw_options = function() { + + var localctx = new Opt_fdw_optionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 336, PostgreSQLParser.RULE_opt_fdw_options); + try { + this.state = 3557; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.NO: + case PostgreSQLParser.VALIDATOR: + this.enterOuterAlt(localctx, 1); + this.state = 3555; + this.fdw_options(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterfdwstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterfdwstmt; + return this; +} + +AlterfdwstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterfdwstmtContext.prototype.constructor = AlterfdwstmtContext; + +AlterfdwstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterfdwstmtContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +AlterfdwstmtContext.prototype.DATA_P = function() { + return this.getToken(PostgreSQLParser.DATA_P, 0); +}; + +AlterfdwstmtContext.prototype.WRAPPER = function() { + return this.getToken(PostgreSQLParser.WRAPPER, 0); +}; + +AlterfdwstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AlterfdwstmtContext.prototype.opt_fdw_options = function() { + return this.getTypedRuleContext(Opt_fdw_optionsContext,0); +}; + +AlterfdwstmtContext.prototype.alter_generic_options = function() { + return this.getTypedRuleContext(Alter_generic_optionsContext,0); +}; + +AlterfdwstmtContext.prototype.fdw_options = function() { + return this.getTypedRuleContext(Fdw_optionsContext,0); +}; + +AlterfdwstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterfdwstmt(this); + } +}; + +AlterfdwstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterfdwstmt(this); + } +}; + +AlterfdwstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterfdwstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterfdwstmtContext = AlterfdwstmtContext; + +PostgreSQLParser.prototype.alterfdwstmt = function() { + + var localctx = new AlterfdwstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 338, PostgreSQLParser.RULE_alterfdwstmt); + try { + this.state = 3574; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,156,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3559; + this.match(PostgreSQLParser.ALTER); + this.state = 3560; + this.match(PostgreSQLParser.FOREIGN); + this.state = 3561; + this.match(PostgreSQLParser.DATA_P); + this.state = 3562; + this.match(PostgreSQLParser.WRAPPER); + this.state = 3563; + this.name(); + this.state = 3564; + this.opt_fdw_options(); + this.state = 3565; + this.alter_generic_options(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3567; + this.match(PostgreSQLParser.ALTER); + this.state = 3568; + this.match(PostgreSQLParser.FOREIGN); + this.state = 3569; + this.match(PostgreSQLParser.DATA_P); + this.state = 3570; + this.match(PostgreSQLParser.WRAPPER); + this.state = 3571; + this.name(); + this.state = 3572; + this.fdw_options(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Create_generic_optionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_create_generic_options; + return this; +} + +Create_generic_optionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Create_generic_optionsContext.prototype.constructor = Create_generic_optionsContext; + +Create_generic_optionsContext.prototype.OPTIONS = function() { + return this.getToken(PostgreSQLParser.OPTIONS, 0); +}; + +Create_generic_optionsContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Create_generic_optionsContext.prototype.generic_option_list = function() { + return this.getTypedRuleContext(Generic_option_listContext,0); +}; + +Create_generic_optionsContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Create_generic_optionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreate_generic_options(this); + } +}; + +Create_generic_optionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreate_generic_options(this); + } +}; + +Create_generic_optionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreate_generic_options(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Create_generic_optionsContext = Create_generic_optionsContext; + +PostgreSQLParser.prototype.create_generic_options = function() { + + var localctx = new Create_generic_optionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 340, PostgreSQLParser.RULE_create_generic_options); + try { + this.state = 3582; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPTIONS: + this.enterOuterAlt(localctx, 1); + this.state = 3576; + this.match(PostgreSQLParser.OPTIONS); + this.state = 3577; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3578; + this.generic_option_list(); + this.state = 3579; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CHECK: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INITIALLY: + case PostgreSQLParser.INTO: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.REFERENCES: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Generic_option_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_generic_option_list; + return this; +} + +Generic_option_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Generic_option_listContext.prototype.constructor = Generic_option_listContext; + +Generic_option_listContext.prototype.generic_option_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Generic_option_elemContext); + } else { + return this.getTypedRuleContext(Generic_option_elemContext,i); + } +}; + +Generic_option_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Generic_option_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGeneric_option_list(this); + } +}; + +Generic_option_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGeneric_option_list(this); + } +}; + +Generic_option_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGeneric_option_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Generic_option_listContext = Generic_option_listContext; + +PostgreSQLParser.prototype.generic_option_list = function() { + + var localctx = new Generic_option_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 342, PostgreSQLParser.RULE_generic_option_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3584; + this.generic_option_elem(); + this.state = 3589; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 3585; + this.match(PostgreSQLParser.COMMA); + this.state = 3586; + this.generic_option_elem(); + this.state = 3591; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_generic_optionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_generic_options; + return this; +} + +Alter_generic_optionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_generic_optionsContext.prototype.constructor = Alter_generic_optionsContext; + +Alter_generic_optionsContext.prototype.OPTIONS = function() { + return this.getToken(PostgreSQLParser.OPTIONS, 0); +}; + +Alter_generic_optionsContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Alter_generic_optionsContext.prototype.alter_generic_option_list = function() { + return this.getTypedRuleContext(Alter_generic_option_listContext,0); +}; + +Alter_generic_optionsContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Alter_generic_optionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_generic_options(this); + } +}; + +Alter_generic_optionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_generic_options(this); + } +}; + +Alter_generic_optionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_generic_options(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_generic_optionsContext = Alter_generic_optionsContext; + +PostgreSQLParser.prototype.alter_generic_options = function() { + + var localctx = new Alter_generic_optionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 344, PostgreSQLParser.RULE_alter_generic_options); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3592; + this.match(PostgreSQLParser.OPTIONS); + this.state = 3593; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3594; + this.alter_generic_option_list(); + this.state = 3595; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_generic_option_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_generic_option_list; + return this; +} + +Alter_generic_option_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_generic_option_listContext.prototype.constructor = Alter_generic_option_listContext; + +Alter_generic_option_listContext.prototype.alter_generic_option_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Alter_generic_option_elemContext); + } else { + return this.getTypedRuleContext(Alter_generic_option_elemContext,i); + } +}; + +Alter_generic_option_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Alter_generic_option_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_generic_option_list(this); + } +}; + +Alter_generic_option_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_generic_option_list(this); + } +}; + +Alter_generic_option_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_generic_option_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_generic_option_listContext = Alter_generic_option_listContext; + +PostgreSQLParser.prototype.alter_generic_option_list = function() { + + var localctx = new Alter_generic_option_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 346, PostgreSQLParser.RULE_alter_generic_option_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3597; + this.alter_generic_option_elem(); + this.state = 3602; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 3598; + this.match(PostgreSQLParser.COMMA); + this.state = 3599; + this.alter_generic_option_elem(); + this.state = 3604; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alter_generic_option_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alter_generic_option_elem; + return this; +} + +Alter_generic_option_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alter_generic_option_elemContext.prototype.constructor = Alter_generic_option_elemContext; + +Alter_generic_option_elemContext.prototype.generic_option_elem = function() { + return this.getTypedRuleContext(Generic_option_elemContext,0); +}; + +Alter_generic_option_elemContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +Alter_generic_option_elemContext.prototype.ADD_P = function() { + return this.getToken(PostgreSQLParser.ADD_P, 0); +}; + +Alter_generic_option_elemContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +Alter_generic_option_elemContext.prototype.generic_option_name = function() { + return this.getTypedRuleContext(Generic_option_nameContext,0); +}; + +Alter_generic_option_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlter_generic_option_elem(this); + } +}; + +Alter_generic_option_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlter_generic_option_elem(this); + } +}; + +Alter_generic_option_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlter_generic_option_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alter_generic_option_elemContext = Alter_generic_option_elemContext; + +PostgreSQLParser.prototype.alter_generic_option_elem = function() { + + var localctx = new Alter_generic_option_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 348, PostgreSQLParser.RULE_alter_generic_option_elem); + try { + this.state = 3612; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,160,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3605; + this.generic_option_elem(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3606; + this.match(PostgreSQLParser.SET); + this.state = 3607; + this.generic_option_elem(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 3608; + this.match(PostgreSQLParser.ADD_P); + this.state = 3609; + this.generic_option_elem(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 3610; + this.match(PostgreSQLParser.DROP); + this.state = 3611; + this.generic_option_name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Generic_option_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_generic_option_elem; + return this; +} + +Generic_option_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Generic_option_elemContext.prototype.constructor = Generic_option_elemContext; + +Generic_option_elemContext.prototype.generic_option_name = function() { + return this.getTypedRuleContext(Generic_option_nameContext,0); +}; + +Generic_option_elemContext.prototype.generic_option_arg = function() { + return this.getTypedRuleContext(Generic_option_argContext,0); +}; + +Generic_option_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGeneric_option_elem(this); + } +}; + +Generic_option_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGeneric_option_elem(this); + } +}; + +Generic_option_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGeneric_option_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Generic_option_elemContext = Generic_option_elemContext; + +PostgreSQLParser.prototype.generic_option_elem = function() { + + var localctx = new Generic_option_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 350, PostgreSQLParser.RULE_generic_option_elem); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3614; + this.generic_option_name(); + this.state = 3615; + this.generic_option_arg(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Generic_option_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_generic_option_name; + return this; +} + +Generic_option_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Generic_option_nameContext.prototype.constructor = Generic_option_nameContext; + +Generic_option_nameContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +Generic_option_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGeneric_option_name(this); + } +}; + +Generic_option_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGeneric_option_name(this); + } +}; + +Generic_option_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGeneric_option_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Generic_option_nameContext = Generic_option_nameContext; + +PostgreSQLParser.prototype.generic_option_name = function() { + + var localctx = new Generic_option_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 352, PostgreSQLParser.RULE_generic_option_name); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3617; + this.collabel(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Generic_option_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_generic_option_arg; + return this; +} + +Generic_option_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Generic_option_argContext.prototype.constructor = Generic_option_argContext; + +Generic_option_argContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Generic_option_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGeneric_option_arg(this); + } +}; + +Generic_option_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGeneric_option_arg(this); + } +}; + +Generic_option_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGeneric_option_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Generic_option_argContext = Generic_option_argContext; + +PostgreSQLParser.prototype.generic_option_arg = function() { + + var localctx = new Generic_option_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 354, PostgreSQLParser.RULE_generic_option_arg); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3619; + this.sconst(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateforeignserverstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createforeignserverstmt; + return this; +} + +CreateforeignserverstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateforeignserverstmtContext.prototype.constructor = CreateforeignserverstmtContext; + +CreateforeignserverstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateforeignserverstmtContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +CreateforeignserverstmtContext.prototype.name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(NameContext); + } else { + return this.getTypedRuleContext(NameContext,i); + } +}; + +CreateforeignserverstmtContext.prototype.opt_type = function() { + return this.getTypedRuleContext(Opt_typeContext,0); +}; + +CreateforeignserverstmtContext.prototype.opt_foreign_server_version = function() { + return this.getTypedRuleContext(Opt_foreign_server_versionContext,0); +}; + +CreateforeignserverstmtContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +CreateforeignserverstmtContext.prototype.DATA_P = function() { + return this.getToken(PostgreSQLParser.DATA_P, 0); +}; + +CreateforeignserverstmtContext.prototype.WRAPPER = function() { + return this.getToken(PostgreSQLParser.WRAPPER, 0); +}; + +CreateforeignserverstmtContext.prototype.create_generic_options = function() { + return this.getTypedRuleContext(Create_generic_optionsContext,0); +}; + +CreateforeignserverstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +CreateforeignserverstmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +CreateforeignserverstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +CreateforeignserverstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateforeignserverstmt(this); + } +}; + +CreateforeignserverstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateforeignserverstmt(this); + } +}; + +CreateforeignserverstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateforeignserverstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateforeignserverstmtContext = CreateforeignserverstmtContext; + +PostgreSQLParser.prototype.createforeignserverstmt = function() { + + var localctx = new CreateforeignserverstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 356, PostgreSQLParser.RULE_createforeignserverstmt); + try { + this.state = 3646; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,161,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3621; + this.match(PostgreSQLParser.CREATE); + this.state = 3622; + this.match(PostgreSQLParser.SERVER); + this.state = 3623; + this.name(); + this.state = 3624; + this.opt_type(); + this.state = 3625; + this.opt_foreign_server_version(); + this.state = 3626; + this.match(PostgreSQLParser.FOREIGN); + this.state = 3627; + this.match(PostgreSQLParser.DATA_P); + this.state = 3628; + this.match(PostgreSQLParser.WRAPPER); + this.state = 3629; + this.name(); + this.state = 3630; + this.create_generic_options(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3632; + this.match(PostgreSQLParser.CREATE); + this.state = 3633; + this.match(PostgreSQLParser.SERVER); + this.state = 3634; + this.match(PostgreSQLParser.IF_P); + this.state = 3635; + this.match(PostgreSQLParser.NOT); + this.state = 3636; + this.match(PostgreSQLParser.EXISTS); + this.state = 3637; + this.name(); + this.state = 3638; + this.opt_type(); + this.state = 3639; + this.opt_foreign_server_version(); + this.state = 3640; + this.match(PostgreSQLParser.FOREIGN); + this.state = 3641; + this.match(PostgreSQLParser.DATA_P); + this.state = 3642; + this.match(PostgreSQLParser.WRAPPER); + this.state = 3643; + this.name(); + this.state = 3644; + this.create_generic_options(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_typeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_type; + return this; +} + +Opt_typeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_typeContext.prototype.constructor = Opt_typeContext; + +Opt_typeContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +Opt_typeContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Opt_typeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_type(this); + } +}; + +Opt_typeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_type(this); + } +}; + +Opt_typeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_type(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_typeContext = Opt_typeContext; + +PostgreSQLParser.prototype.opt_type = function() { + + var localctx = new Opt_typeContext(this, this._ctx, this.state); + this.enterRule(localctx, 358, PostgreSQLParser.RULE_opt_type); + try { + this.state = 3651; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.TYPE_P: + this.enterOuterAlt(localctx, 1); + this.state = 3648; + this.match(PostgreSQLParser.TYPE_P); + this.state = 3649; + this.sconst(); + break; + case PostgreSQLParser.FOREIGN: + case PostgreSQLParser.VERSION_P: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Foreign_server_versionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_foreign_server_version; + return this; +} + +Foreign_server_versionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Foreign_server_versionContext.prototype.constructor = Foreign_server_versionContext; + +Foreign_server_versionContext.prototype.VERSION_P = function() { + return this.getToken(PostgreSQLParser.VERSION_P, 0); +}; + +Foreign_server_versionContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Foreign_server_versionContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +Foreign_server_versionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterForeign_server_version(this); + } +}; + +Foreign_server_versionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitForeign_server_version(this); + } +}; + +Foreign_server_versionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitForeign_server_version(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Foreign_server_versionContext = Foreign_server_versionContext; + +PostgreSQLParser.prototype.foreign_server_version = function() { + + var localctx = new Foreign_server_versionContext(this, this._ctx, this.state); + this.enterRule(localctx, 360, PostgreSQLParser.RULE_foreign_server_version); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3653; + this.match(PostgreSQLParser.VERSION_P); + this.state = 3656; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.state = 3654; + this.sconst(); + break; + case PostgreSQLParser.NULL_P: + this.state = 3655; + this.match(PostgreSQLParser.NULL_P); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_foreign_server_versionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_foreign_server_version; + return this; +} + +Opt_foreign_server_versionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_foreign_server_versionContext.prototype.constructor = Opt_foreign_server_versionContext; + +Opt_foreign_server_versionContext.prototype.foreign_server_version = function() { + return this.getTypedRuleContext(Foreign_server_versionContext,0); +}; + +Opt_foreign_server_versionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_foreign_server_version(this); + } +}; + +Opt_foreign_server_versionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_foreign_server_version(this); + } +}; + +Opt_foreign_server_versionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_foreign_server_version(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_foreign_server_versionContext = Opt_foreign_server_versionContext; + +PostgreSQLParser.prototype.opt_foreign_server_version = function() { + + var localctx = new Opt_foreign_server_versionContext(this, this._ctx, this.state); + this.enterRule(localctx, 362, PostgreSQLParser.RULE_opt_foreign_server_version); + try { + this.state = 3660; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.VERSION_P: + this.enterOuterAlt(localctx, 1); + this.state = 3658; + this.foreign_server_version(); + break; + case PostgreSQLParser.FOREIGN: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterforeignserverstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterforeignserverstmt; + return this; +} + +AlterforeignserverstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterforeignserverstmtContext.prototype.constructor = AlterforeignserverstmtContext; + +AlterforeignserverstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterforeignserverstmtContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +AlterforeignserverstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AlterforeignserverstmtContext.prototype.alter_generic_options = function() { + return this.getTypedRuleContext(Alter_generic_optionsContext,0); +}; + +AlterforeignserverstmtContext.prototype.foreign_server_version = function() { + return this.getTypedRuleContext(Foreign_server_versionContext,0); +}; + +AlterforeignserverstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterforeignserverstmt(this); + } +}; + +AlterforeignserverstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterforeignserverstmt(this); + } +}; + +AlterforeignserverstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterforeignserverstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterforeignserverstmtContext = AlterforeignserverstmtContext; + +PostgreSQLParser.prototype.alterforeignserverstmt = function() { + + var localctx = new AlterforeignserverstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 364, PostgreSQLParser.RULE_alterforeignserverstmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3662; + this.match(PostgreSQLParser.ALTER); + this.state = 3663; + this.match(PostgreSQLParser.SERVER); + this.state = 3664; + this.name(); + this.state = 3670; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPTIONS: + this.state = 3665; + this.alter_generic_options(); + break; + case PostgreSQLParser.VERSION_P: + this.state = 3666; + this.foreign_server_version(); + this.state = 3668; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OPTIONS) { + this.state = 3667; + this.alter_generic_options(); + } + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateforeigntablestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createforeigntablestmt; + return this; +} + +CreateforeigntablestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateforeigntablestmtContext.prototype.constructor = CreateforeigntablestmtContext; + +CreateforeigntablestmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateforeigntablestmtContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +CreateforeigntablestmtContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +CreateforeigntablestmtContext.prototype.qualified_name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Qualified_nameContext); + } else { + return this.getTypedRuleContext(Qualified_nameContext,i); + } +}; + +CreateforeigntablestmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CreateforeigntablestmtContext.prototype.opttableelementlist = function() { + return this.getTypedRuleContext(OpttableelementlistContext,0); +}; + +CreateforeigntablestmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CreateforeigntablestmtContext.prototype.optinherit = function() { + return this.getTypedRuleContext(OptinheritContext,0); +}; + +CreateforeigntablestmtContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +CreateforeigntablestmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreateforeigntablestmtContext.prototype.create_generic_options = function() { + return this.getTypedRuleContext(Create_generic_optionsContext,0); +}; + +CreateforeigntablestmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +CreateforeigntablestmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +CreateforeigntablestmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +CreateforeigntablestmtContext.prototype.PARTITION = function() { + return this.getToken(PostgreSQLParser.PARTITION, 0); +}; + +CreateforeigntablestmtContext.prototype.OF = function() { + return this.getToken(PostgreSQLParser.OF, 0); +}; + +CreateforeigntablestmtContext.prototype.opttypedtableelementlist = function() { + return this.getTypedRuleContext(OpttypedtableelementlistContext,0); +}; + +CreateforeigntablestmtContext.prototype.partitionboundspec = function() { + return this.getTypedRuleContext(PartitionboundspecContext,0); +}; + +CreateforeigntablestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateforeigntablestmt(this); + } +}; + +CreateforeigntablestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateforeigntablestmt(this); + } +}; + +CreateforeigntablestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateforeigntablestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateforeigntablestmtContext = CreateforeigntablestmtContext; + +PostgreSQLParser.prototype.createforeigntablestmt = function() { + + var localctx = new CreateforeigntablestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 366, PostgreSQLParser.RULE_createforeigntablestmt); + try { + this.state = 3728; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,167,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3672; + this.match(PostgreSQLParser.CREATE); + this.state = 3673; + this.match(PostgreSQLParser.FOREIGN); + this.state = 3674; + this.match(PostgreSQLParser.TABLE); + this.state = 3675; + this.qualified_name(); + this.state = 3676; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3677; + this.opttableelementlist(); + this.state = 3678; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 3679; + this.optinherit(); + this.state = 3680; + this.match(PostgreSQLParser.SERVER); + this.state = 3681; + this.name(); + this.state = 3682; + this.create_generic_options(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3684; + this.match(PostgreSQLParser.CREATE); + this.state = 3685; + this.match(PostgreSQLParser.FOREIGN); + this.state = 3686; + this.match(PostgreSQLParser.TABLE); + this.state = 3687; + this.match(PostgreSQLParser.IF_P); + this.state = 3688; + this.match(PostgreSQLParser.NOT); + this.state = 3689; + this.match(PostgreSQLParser.EXISTS); + this.state = 3690; + this.qualified_name(); + this.state = 3691; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3692; + this.opttableelementlist(); + this.state = 3693; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 3694; + this.optinherit(); + this.state = 3695; + this.match(PostgreSQLParser.SERVER); + this.state = 3696; + this.name(); + this.state = 3697; + this.create_generic_options(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 3699; + this.match(PostgreSQLParser.CREATE); + this.state = 3700; + this.match(PostgreSQLParser.FOREIGN); + this.state = 3701; + this.match(PostgreSQLParser.TABLE); + this.state = 3702; + this.qualified_name(); + this.state = 3703; + this.match(PostgreSQLParser.PARTITION); + this.state = 3704; + this.match(PostgreSQLParser.OF); + this.state = 3705; + this.qualified_name(); + this.state = 3706; + this.opttypedtableelementlist(); + this.state = 3707; + this.partitionboundspec(); + this.state = 3708; + this.match(PostgreSQLParser.SERVER); + this.state = 3709; + this.name(); + this.state = 3710; + this.create_generic_options(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 3712; + this.match(PostgreSQLParser.CREATE); + this.state = 3713; + this.match(PostgreSQLParser.FOREIGN); + this.state = 3714; + this.match(PostgreSQLParser.TABLE); + this.state = 3715; + this.match(PostgreSQLParser.IF_P); + this.state = 3716; + this.match(PostgreSQLParser.NOT); + this.state = 3717; + this.match(PostgreSQLParser.EXISTS); + this.state = 3718; + this.qualified_name(); + this.state = 3719; + this.match(PostgreSQLParser.PARTITION); + this.state = 3720; + this.match(PostgreSQLParser.OF); + this.state = 3721; + this.qualified_name(); + this.state = 3722; + this.opttypedtableelementlist(); + this.state = 3723; + this.partitionboundspec(); + this.state = 3724; + this.match(PostgreSQLParser.SERVER); + this.state = 3725; + this.name(); + this.state = 3726; + this.create_generic_options(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ImportforeignschemastmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_importforeignschemastmt; + return this; +} + +ImportforeignschemastmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ImportforeignschemastmtContext.prototype.constructor = ImportforeignschemastmtContext; + +ImportforeignschemastmtContext.prototype.IMPORT_P = function() { + return this.getToken(PostgreSQLParser.IMPORT_P, 0); +}; + +ImportforeignschemastmtContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +ImportforeignschemastmtContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +ImportforeignschemastmtContext.prototype.name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(NameContext); + } else { + return this.getTypedRuleContext(NameContext,i); + } +}; + +ImportforeignschemastmtContext.prototype.import_qualification = function() { + return this.getTypedRuleContext(Import_qualificationContext,0); +}; + +ImportforeignschemastmtContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +ImportforeignschemastmtContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +ImportforeignschemastmtContext.prototype.INTO = function() { + return this.getToken(PostgreSQLParser.INTO, 0); +}; + +ImportforeignschemastmtContext.prototype.create_generic_options = function() { + return this.getTypedRuleContext(Create_generic_optionsContext,0); +}; + +ImportforeignschemastmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterImportforeignschemastmt(this); + } +}; + +ImportforeignschemastmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitImportforeignschemastmt(this); + } +}; + +ImportforeignschemastmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitImportforeignschemastmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ImportforeignschemastmtContext = ImportforeignschemastmtContext; + +PostgreSQLParser.prototype.importforeignschemastmt = function() { + + var localctx = new ImportforeignschemastmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 368, PostgreSQLParser.RULE_importforeignschemastmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3730; + this.match(PostgreSQLParser.IMPORT_P); + this.state = 3731; + this.match(PostgreSQLParser.FOREIGN); + this.state = 3732; + this.match(PostgreSQLParser.SCHEMA); + this.state = 3733; + this.name(); + this.state = 3734; + this.import_qualification(); + this.state = 3735; + this.match(PostgreSQLParser.FROM); + this.state = 3736; + this.match(PostgreSQLParser.SERVER); + this.state = 3737; + this.name(); + this.state = 3738; + this.match(PostgreSQLParser.INTO); + this.state = 3739; + this.name(); + this.state = 3740; + this.create_generic_options(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Import_qualification_typeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_import_qualification_type; + return this; +} + +Import_qualification_typeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Import_qualification_typeContext.prototype.constructor = Import_qualification_typeContext; + +Import_qualification_typeContext.prototype.LIMIT = function() { + return this.getToken(PostgreSQLParser.LIMIT, 0); +}; + +Import_qualification_typeContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +Import_qualification_typeContext.prototype.EXCEPT = function() { + return this.getToken(PostgreSQLParser.EXCEPT, 0); +}; + +Import_qualification_typeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterImport_qualification_type(this); + } +}; + +Import_qualification_typeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitImport_qualification_type(this); + } +}; + +Import_qualification_typeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitImport_qualification_type(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Import_qualification_typeContext = Import_qualification_typeContext; + +PostgreSQLParser.prototype.import_qualification_type = function() { + + var localctx = new Import_qualification_typeContext(this, this._ctx, this.state); + this.enterRule(localctx, 370, PostgreSQLParser.RULE_import_qualification_type); + try { + this.state = 3745; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.LIMIT: + this.enterOuterAlt(localctx, 1); + this.state = 3742; + this.match(PostgreSQLParser.LIMIT); + this.state = 3743; + this.match(PostgreSQLParser.TO); + break; + case PostgreSQLParser.EXCEPT: + this.enterOuterAlt(localctx, 2); + this.state = 3744; + this.match(PostgreSQLParser.EXCEPT); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Import_qualificationContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_import_qualification; + return this; +} + +Import_qualificationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Import_qualificationContext.prototype.constructor = Import_qualificationContext; + +Import_qualificationContext.prototype.import_qualification_type = function() { + return this.getTypedRuleContext(Import_qualification_typeContext,0); +}; + +Import_qualificationContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Import_qualificationContext.prototype.relation_expr_list = function() { + return this.getTypedRuleContext(Relation_expr_listContext,0); +}; + +Import_qualificationContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Import_qualificationContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterImport_qualification(this); + } +}; + +Import_qualificationContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitImport_qualification(this); + } +}; + +Import_qualificationContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitImport_qualification(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Import_qualificationContext = Import_qualificationContext; + +PostgreSQLParser.prototype.import_qualification = function() { + + var localctx = new Import_qualificationContext(this, this._ctx, this.state); + this.enterRule(localctx, 372, PostgreSQLParser.RULE_import_qualification); + try { + this.state = 3753; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.LIMIT: + this.enterOuterAlt(localctx, 1); + this.state = 3747; + this.import_qualification_type(); + this.state = 3748; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3749; + this.relation_expr_list(); + this.state = 3750; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.FROM: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateusermappingstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createusermappingstmt; + return this; +} + +CreateusermappingstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateusermappingstmtContext.prototype.constructor = CreateusermappingstmtContext; + +CreateusermappingstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateusermappingstmtContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +CreateusermappingstmtContext.prototype.MAPPING = function() { + return this.getToken(PostgreSQLParser.MAPPING, 0); +}; + +CreateusermappingstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +CreateusermappingstmtContext.prototype.auth_ident = function() { + return this.getTypedRuleContext(Auth_identContext,0); +}; + +CreateusermappingstmtContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +CreateusermappingstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreateusermappingstmtContext.prototype.create_generic_options = function() { + return this.getTypedRuleContext(Create_generic_optionsContext,0); +}; + +CreateusermappingstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +CreateusermappingstmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +CreateusermappingstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +CreateusermappingstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateusermappingstmt(this); + } +}; + +CreateusermappingstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateusermappingstmt(this); + } +}; + +CreateusermappingstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateusermappingstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateusermappingstmtContext = CreateusermappingstmtContext; + +PostgreSQLParser.prototype.createusermappingstmt = function() { + + var localctx = new CreateusermappingstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 374, PostgreSQLParser.RULE_createusermappingstmt); + try { + this.state = 3776; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,170,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3755; + this.match(PostgreSQLParser.CREATE); + this.state = 3756; + this.match(PostgreSQLParser.USER); + this.state = 3757; + this.match(PostgreSQLParser.MAPPING); + this.state = 3758; + this.match(PostgreSQLParser.FOR); + this.state = 3759; + this.auth_ident(); + this.state = 3760; + this.match(PostgreSQLParser.SERVER); + this.state = 3761; + this.name(); + this.state = 3762; + this.create_generic_options(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3764; + this.match(PostgreSQLParser.CREATE); + this.state = 3765; + this.match(PostgreSQLParser.USER); + this.state = 3766; + this.match(PostgreSQLParser.MAPPING); + this.state = 3767; + this.match(PostgreSQLParser.IF_P); + this.state = 3768; + this.match(PostgreSQLParser.NOT); + this.state = 3769; + this.match(PostgreSQLParser.EXISTS); + this.state = 3770; + this.match(PostgreSQLParser.FOR); + this.state = 3771; + this.auth_ident(); + this.state = 3772; + this.match(PostgreSQLParser.SERVER); + this.state = 3773; + this.name(); + this.state = 3774; + this.create_generic_options(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Auth_identContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_auth_ident; + return this; +} + +Auth_identContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Auth_identContext.prototype.constructor = Auth_identContext; + +Auth_identContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +Auth_identContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +Auth_identContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAuth_ident(this); + } +}; + +Auth_identContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAuth_ident(this); + } +}; + +Auth_identContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAuth_ident(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Auth_identContext = Auth_identContext; + +PostgreSQLParser.prototype.auth_ident = function() { + + var localctx = new Auth_identContext(this, this._ctx, this.state); + this.enterRule(localctx, 376, PostgreSQLParser.RULE_auth_ident); + try { + this.state = 3780; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 3778; + this.rolespec(); + break; + case PostgreSQLParser.USER: + this.enterOuterAlt(localctx, 2); + this.state = 3779; + this.match(PostgreSQLParser.USER); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DropusermappingstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dropusermappingstmt; + return this; +} + +DropusermappingstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DropusermappingstmtContext.prototype.constructor = DropusermappingstmtContext; + +DropusermappingstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DropusermappingstmtContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +DropusermappingstmtContext.prototype.MAPPING = function() { + return this.getToken(PostgreSQLParser.MAPPING, 0); +}; + +DropusermappingstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +DropusermappingstmtContext.prototype.auth_ident = function() { + return this.getTypedRuleContext(Auth_identContext,0); +}; + +DropusermappingstmtContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +DropusermappingstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +DropusermappingstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +DropusermappingstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +DropusermappingstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDropusermappingstmt(this); + } +}; + +DropusermappingstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDropusermappingstmt(this); + } +}; + +DropusermappingstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDropusermappingstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DropusermappingstmtContext = DropusermappingstmtContext; + +PostgreSQLParser.prototype.dropusermappingstmt = function() { + + var localctx = new DropusermappingstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 378, PostgreSQLParser.RULE_dropusermappingstmt); + try { + this.state = 3800; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,172,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3782; + this.match(PostgreSQLParser.DROP); + this.state = 3783; + this.match(PostgreSQLParser.USER); + this.state = 3784; + this.match(PostgreSQLParser.MAPPING); + this.state = 3785; + this.match(PostgreSQLParser.FOR); + this.state = 3786; + this.auth_ident(); + this.state = 3787; + this.match(PostgreSQLParser.SERVER); + this.state = 3788; + this.name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3790; + this.match(PostgreSQLParser.DROP); + this.state = 3791; + this.match(PostgreSQLParser.USER); + this.state = 3792; + this.match(PostgreSQLParser.MAPPING); + this.state = 3793; + this.match(PostgreSQLParser.IF_P); + this.state = 3794; + this.match(PostgreSQLParser.EXISTS); + this.state = 3795; + this.match(PostgreSQLParser.FOR); + this.state = 3796; + this.auth_ident(); + this.state = 3797; + this.match(PostgreSQLParser.SERVER); + this.state = 3798; + this.name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterusermappingstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterusermappingstmt; + return this; +} + +AlterusermappingstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterusermappingstmtContext.prototype.constructor = AlterusermappingstmtContext; + +AlterusermappingstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterusermappingstmtContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +AlterusermappingstmtContext.prototype.MAPPING = function() { + return this.getToken(PostgreSQLParser.MAPPING, 0); +}; + +AlterusermappingstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +AlterusermappingstmtContext.prototype.auth_ident = function() { + return this.getTypedRuleContext(Auth_identContext,0); +}; + +AlterusermappingstmtContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +AlterusermappingstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AlterusermappingstmtContext.prototype.alter_generic_options = function() { + return this.getTypedRuleContext(Alter_generic_optionsContext,0); +}; + +AlterusermappingstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterusermappingstmt(this); + } +}; + +AlterusermappingstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterusermappingstmt(this); + } +}; + +AlterusermappingstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterusermappingstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterusermappingstmtContext = AlterusermappingstmtContext; + +PostgreSQLParser.prototype.alterusermappingstmt = function() { + + var localctx = new AlterusermappingstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 380, PostgreSQLParser.RULE_alterusermappingstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3802; + this.match(PostgreSQLParser.ALTER); + this.state = 3803; + this.match(PostgreSQLParser.USER); + this.state = 3804; + this.match(PostgreSQLParser.MAPPING); + this.state = 3805; + this.match(PostgreSQLParser.FOR); + this.state = 3806; + this.auth_ident(); + this.state = 3807; + this.match(PostgreSQLParser.SERVER); + this.state = 3808; + this.name(); + this.state = 3809; + this.alter_generic_options(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatepolicystmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createpolicystmt; + return this; +} + +CreatepolicystmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatepolicystmtContext.prototype.constructor = CreatepolicystmtContext; + +CreatepolicystmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatepolicystmtContext.prototype.POLICY = function() { + return this.getToken(PostgreSQLParser.POLICY, 0); +}; + +CreatepolicystmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreatepolicystmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +CreatepolicystmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +CreatepolicystmtContext.prototype.rowsecuritydefaultpermissive = function() { + return this.getTypedRuleContext(RowsecuritydefaultpermissiveContext,0); +}; + +CreatepolicystmtContext.prototype.rowsecuritydefaultforcmd = function() { + return this.getTypedRuleContext(RowsecuritydefaultforcmdContext,0); +}; + +CreatepolicystmtContext.prototype.rowsecuritydefaulttorole = function() { + return this.getTypedRuleContext(RowsecuritydefaulttoroleContext,0); +}; + +CreatepolicystmtContext.prototype.rowsecurityoptionalexpr = function() { + return this.getTypedRuleContext(RowsecurityoptionalexprContext,0); +}; + +CreatepolicystmtContext.prototype.rowsecurityoptionalwithcheck = function() { + return this.getTypedRuleContext(RowsecurityoptionalwithcheckContext,0); +}; + +CreatepolicystmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatepolicystmt(this); + } +}; + +CreatepolicystmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatepolicystmt(this); + } +}; + +CreatepolicystmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatepolicystmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatepolicystmtContext = CreatepolicystmtContext; + +PostgreSQLParser.prototype.createpolicystmt = function() { + + var localctx = new CreatepolicystmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 382, PostgreSQLParser.RULE_createpolicystmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3811; + this.match(PostgreSQLParser.CREATE); + this.state = 3812; + this.match(PostgreSQLParser.POLICY); + this.state = 3813; + this.name(); + this.state = 3814; + this.match(PostgreSQLParser.ON); + this.state = 3815; + this.qualified_name(); + this.state = 3816; + this.rowsecuritydefaultpermissive(); + this.state = 3817; + this.rowsecuritydefaultforcmd(); + this.state = 3818; + this.rowsecuritydefaulttorole(); + this.state = 3819; + this.rowsecurityoptionalexpr(); + this.state = 3820; + this.rowsecurityoptionalwithcheck(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterpolicystmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterpolicystmt; + return this; +} + +AlterpolicystmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterpolicystmtContext.prototype.constructor = AlterpolicystmtContext; + +AlterpolicystmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterpolicystmtContext.prototype.POLICY = function() { + return this.getToken(PostgreSQLParser.POLICY, 0); +}; + +AlterpolicystmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AlterpolicystmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +AlterpolicystmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +AlterpolicystmtContext.prototype.rowsecurityoptionaltorole = function() { + return this.getTypedRuleContext(RowsecurityoptionaltoroleContext,0); +}; + +AlterpolicystmtContext.prototype.rowsecurityoptionalexpr = function() { + return this.getTypedRuleContext(RowsecurityoptionalexprContext,0); +}; + +AlterpolicystmtContext.prototype.rowsecurityoptionalwithcheck = function() { + return this.getTypedRuleContext(RowsecurityoptionalwithcheckContext,0); +}; + +AlterpolicystmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterpolicystmt(this); + } +}; + +AlterpolicystmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterpolicystmt(this); + } +}; + +AlterpolicystmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterpolicystmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterpolicystmtContext = AlterpolicystmtContext; + +PostgreSQLParser.prototype.alterpolicystmt = function() { + + var localctx = new AlterpolicystmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 384, PostgreSQLParser.RULE_alterpolicystmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3822; + this.match(PostgreSQLParser.ALTER); + this.state = 3823; + this.match(PostgreSQLParser.POLICY); + this.state = 3824; + this.name(); + this.state = 3825; + this.match(PostgreSQLParser.ON); + this.state = 3826; + this.qualified_name(); + this.state = 3827; + this.rowsecurityoptionaltorole(); + this.state = 3828; + this.rowsecurityoptionalexpr(); + this.state = 3829; + this.rowsecurityoptionalwithcheck(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RowsecurityoptionalexprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rowsecurityoptionalexpr; + return this; +} + +RowsecurityoptionalexprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RowsecurityoptionalexprContext.prototype.constructor = RowsecurityoptionalexprContext; + +RowsecurityoptionalexprContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +RowsecurityoptionalexprContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +RowsecurityoptionalexprContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +RowsecurityoptionalexprContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +RowsecurityoptionalexprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRowsecurityoptionalexpr(this); + } +}; + +RowsecurityoptionalexprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRowsecurityoptionalexpr(this); + } +}; + +RowsecurityoptionalexprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRowsecurityoptionalexpr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RowsecurityoptionalexprContext = RowsecurityoptionalexprContext; + +PostgreSQLParser.prototype.rowsecurityoptionalexpr = function() { + + var localctx = new RowsecurityoptionalexprContext(this, this._ctx, this.state); + this.enterRule(localctx, 386, PostgreSQLParser.RULE_rowsecurityoptionalexpr); + try { + this.state = 3837; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + this.state = 3831; + this.match(PostgreSQLParser.USING); + this.state = 3832; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3833; + this.a_expr(); + this.state = 3834; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RowsecurityoptionalwithcheckContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rowsecurityoptionalwithcheck; + return this; +} + +RowsecurityoptionalwithcheckContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RowsecurityoptionalwithcheckContext.prototype.constructor = RowsecurityoptionalwithcheckContext; + +RowsecurityoptionalwithcheckContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +RowsecurityoptionalwithcheckContext.prototype.CHECK = function() { + return this.getToken(PostgreSQLParser.CHECK, 0); +}; + +RowsecurityoptionalwithcheckContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +RowsecurityoptionalwithcheckContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +RowsecurityoptionalwithcheckContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +RowsecurityoptionalwithcheckContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRowsecurityoptionalwithcheck(this); + } +}; + +RowsecurityoptionalwithcheckContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRowsecurityoptionalwithcheck(this); + } +}; + +RowsecurityoptionalwithcheckContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRowsecurityoptionalwithcheck(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RowsecurityoptionalwithcheckContext = RowsecurityoptionalwithcheckContext; + +PostgreSQLParser.prototype.rowsecurityoptionalwithcheck = function() { + + var localctx = new RowsecurityoptionalwithcheckContext(this, this._ctx, this.state); + this.enterRule(localctx, 388, PostgreSQLParser.RULE_rowsecurityoptionalwithcheck); + try { + this.state = 3846; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,174,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3839; + this.match(PostgreSQLParser.WITH); + this.state = 3840; + this.match(PostgreSQLParser.CHECK); + this.state = 3841; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3842; + this.a_expr(); + this.state = 3843; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RowsecuritydefaulttoroleContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rowsecuritydefaulttorole; + return this; +} + +RowsecuritydefaulttoroleContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RowsecuritydefaulttoroleContext.prototype.constructor = RowsecuritydefaulttoroleContext; + +RowsecuritydefaulttoroleContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +RowsecuritydefaulttoroleContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +RowsecuritydefaulttoroleContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRowsecuritydefaulttorole(this); + } +}; + +RowsecuritydefaulttoroleContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRowsecuritydefaulttorole(this); + } +}; + +RowsecuritydefaulttoroleContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRowsecuritydefaulttorole(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RowsecuritydefaulttoroleContext = RowsecuritydefaulttoroleContext; + +PostgreSQLParser.prototype.rowsecuritydefaulttorole = function() { + + var localctx = new RowsecuritydefaulttoroleContext(this, this._ctx, this.state); + this.enterRule(localctx, 390, PostgreSQLParser.RULE_rowsecuritydefaulttorole); + try { + this.state = 3851; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.TO: + this.enterOuterAlt(localctx, 1); + this.state = 3848; + this.match(PostgreSQLParser.TO); + this.state = 3849; + this.role_list(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.USING: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RowsecurityoptionaltoroleContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rowsecurityoptionaltorole; + return this; +} + +RowsecurityoptionaltoroleContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RowsecurityoptionaltoroleContext.prototype.constructor = RowsecurityoptionaltoroleContext; + +RowsecurityoptionaltoroleContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +RowsecurityoptionaltoroleContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +RowsecurityoptionaltoroleContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRowsecurityoptionaltorole(this); + } +}; + +RowsecurityoptionaltoroleContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRowsecurityoptionaltorole(this); + } +}; + +RowsecurityoptionaltoroleContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRowsecurityoptionaltorole(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RowsecurityoptionaltoroleContext = RowsecurityoptionaltoroleContext; + +PostgreSQLParser.prototype.rowsecurityoptionaltorole = function() { + + var localctx = new RowsecurityoptionaltoroleContext(this, this._ctx, this.state); + this.enterRule(localctx, 392, PostgreSQLParser.RULE_rowsecurityoptionaltorole); + try { + this.state = 3856; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.TO: + this.enterOuterAlt(localctx, 1); + this.state = 3853; + this.match(PostgreSQLParser.TO); + this.state = 3854; + this.role_list(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.USING: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RowsecuritydefaultpermissiveContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rowsecuritydefaultpermissive; + return this; +} + +RowsecuritydefaultpermissiveContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RowsecuritydefaultpermissiveContext.prototype.constructor = RowsecuritydefaultpermissiveContext; + +RowsecuritydefaultpermissiveContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +RowsecuritydefaultpermissiveContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +RowsecuritydefaultpermissiveContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRowsecuritydefaultpermissive(this); + } +}; + +RowsecuritydefaultpermissiveContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRowsecuritydefaultpermissive(this); + } +}; + +RowsecuritydefaultpermissiveContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRowsecuritydefaultpermissive(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RowsecuritydefaultpermissiveContext = RowsecuritydefaultpermissiveContext; + +PostgreSQLParser.prototype.rowsecuritydefaultpermissive = function() { + + var localctx = new RowsecuritydefaultpermissiveContext(this, this._ctx, this.state); + this.enterRule(localctx, 394, PostgreSQLParser.RULE_rowsecuritydefaultpermissive); + try { + this.state = 3861; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AS: + this.enterOuterAlt(localctx, 1); + this.state = 3858; + this.match(PostgreSQLParser.AS); + this.state = 3859; + this.identifier(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TO: + case PostgreSQLParser.USING: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RowsecuritydefaultforcmdContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rowsecuritydefaultforcmd; + return this; +} + +RowsecuritydefaultforcmdContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RowsecuritydefaultforcmdContext.prototype.constructor = RowsecuritydefaultforcmdContext; + +RowsecuritydefaultforcmdContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +RowsecuritydefaultforcmdContext.prototype.row_security_cmd = function() { + return this.getTypedRuleContext(Row_security_cmdContext,0); +}; + +RowsecuritydefaultforcmdContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRowsecuritydefaultforcmd(this); + } +}; + +RowsecuritydefaultforcmdContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRowsecuritydefaultforcmd(this); + } +}; + +RowsecuritydefaultforcmdContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRowsecuritydefaultforcmd(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RowsecuritydefaultforcmdContext = RowsecuritydefaultforcmdContext; + +PostgreSQLParser.prototype.rowsecuritydefaultforcmd = function() { + + var localctx = new RowsecuritydefaultforcmdContext(this, this._ctx, this.state); + this.enterRule(localctx, 396, PostgreSQLParser.RULE_rowsecuritydefaultforcmd); + try { + this.state = 3866; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FOR: + this.enterOuterAlt(localctx, 1); + this.state = 3863; + this.match(PostgreSQLParser.FOR); + this.state = 3864; + this.row_security_cmd(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TO: + case PostgreSQLParser.USING: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Row_security_cmdContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_row_security_cmd; + return this; +} + +Row_security_cmdContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Row_security_cmdContext.prototype.constructor = Row_security_cmdContext; + +Row_security_cmdContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Row_security_cmdContext.prototype.SELECT = function() { + return this.getToken(PostgreSQLParser.SELECT, 0); +}; + +Row_security_cmdContext.prototype.INSERT = function() { + return this.getToken(PostgreSQLParser.INSERT, 0); +}; + +Row_security_cmdContext.prototype.UPDATE = function() { + return this.getToken(PostgreSQLParser.UPDATE, 0); +}; + +Row_security_cmdContext.prototype.DELETE_P = function() { + return this.getToken(PostgreSQLParser.DELETE_P, 0); +}; + +Row_security_cmdContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRow_security_cmd(this); + } +}; + +Row_security_cmdContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRow_security_cmd(this); + } +}; + +Row_security_cmdContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRow_security_cmd(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Row_security_cmdContext = Row_security_cmdContext; + +PostgreSQLParser.prototype.row_security_cmd = function() { + + var localctx = new Row_security_cmdContext(this, this._ctx, this.state); + this.enterRule(localctx, 398, PostgreSQLParser.RULE_row_security_cmd); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3868; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.ALL || _la===PostgreSQLParser.SELECT || _la===PostgreSQLParser.DELETE_P || _la===PostgreSQLParser.INSERT || _la===PostgreSQLParser.UPDATE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateamstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createamstmt; + return this; +} + +CreateamstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateamstmtContext.prototype.constructor = CreateamstmtContext; + +CreateamstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateamstmtContext.prototype.ACCESS = function() { + return this.getToken(PostgreSQLParser.ACCESS, 0); +}; + +CreateamstmtContext.prototype.METHOD = function() { + return this.getToken(PostgreSQLParser.METHOD, 0); +}; + +CreateamstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreateamstmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +CreateamstmtContext.prototype.am_type = function() { + return this.getTypedRuleContext(Am_typeContext,0); +}; + +CreateamstmtContext.prototype.HANDLER = function() { + return this.getToken(PostgreSQLParser.HANDLER, 0); +}; + +CreateamstmtContext.prototype.handler_name = function() { + return this.getTypedRuleContext(Handler_nameContext,0); +}; + +CreateamstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateamstmt(this); + } +}; + +CreateamstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateamstmt(this); + } +}; + +CreateamstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateamstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateamstmtContext = CreateamstmtContext; + +PostgreSQLParser.prototype.createamstmt = function() { + + var localctx = new CreateamstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 400, PostgreSQLParser.RULE_createamstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3870; + this.match(PostgreSQLParser.CREATE); + this.state = 3871; + this.match(PostgreSQLParser.ACCESS); + this.state = 3872; + this.match(PostgreSQLParser.METHOD); + this.state = 3873; + this.name(); + this.state = 3874; + this.match(PostgreSQLParser.TYPE_P); + this.state = 3875; + this.am_type(); + this.state = 3876; + this.match(PostgreSQLParser.HANDLER); + this.state = 3877; + this.handler_name(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Am_typeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_am_type; + return this; +} + +Am_typeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Am_typeContext.prototype.constructor = Am_typeContext; + +Am_typeContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +Am_typeContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +Am_typeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAm_type(this); + } +}; + +Am_typeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAm_type(this); + } +}; + +Am_typeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAm_type(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Am_typeContext = Am_typeContext; + +PostgreSQLParser.prototype.am_type = function() { + + var localctx = new Am_typeContext(this, this._ctx, this.state); + this.enterRule(localctx, 402, PostgreSQLParser.RULE_am_type); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3879; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.TABLE || _la===PostgreSQLParser.INDEX)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatetrigstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createtrigstmt; + return this; +} + +CreatetrigstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatetrigstmtContext.prototype.constructor = CreatetrigstmtContext; + +CreatetrigstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatetrigstmtContext.prototype.TRIGGER = function() { + return this.getToken(PostgreSQLParser.TRIGGER, 0); +}; + +CreatetrigstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreatetrigstmtContext.prototype.triggeractiontime = function() { + return this.getTypedRuleContext(TriggeractiontimeContext,0); +}; + +CreatetrigstmtContext.prototype.triggerevents = function() { + return this.getTypedRuleContext(TriggereventsContext,0); +}; + +CreatetrigstmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +CreatetrigstmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +CreatetrigstmtContext.prototype.triggerreferencing = function() { + return this.getTypedRuleContext(TriggerreferencingContext,0); +}; + +CreatetrigstmtContext.prototype.triggerforspec = function() { + return this.getTypedRuleContext(TriggerforspecContext,0); +}; + +CreatetrigstmtContext.prototype.triggerwhen = function() { + return this.getTypedRuleContext(TriggerwhenContext,0); +}; + +CreatetrigstmtContext.prototype.EXECUTE = function() { + return this.getToken(PostgreSQLParser.EXECUTE, 0); +}; + +CreatetrigstmtContext.prototype.function_or_procedure = function() { + return this.getTypedRuleContext(Function_or_procedureContext,0); +}; + +CreatetrigstmtContext.prototype.func_name = function() { + return this.getTypedRuleContext(Func_nameContext,0); +}; + +CreatetrigstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CreatetrigstmtContext.prototype.triggerfuncargs = function() { + return this.getTypedRuleContext(TriggerfuncargsContext,0); +}; + +CreatetrigstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CreatetrigstmtContext.prototype.CONSTRAINT = function() { + return this.getToken(PostgreSQLParser.CONSTRAINT, 0); +}; + +CreatetrigstmtContext.prototype.AFTER = function() { + return this.getToken(PostgreSQLParser.AFTER, 0); +}; + +CreatetrigstmtContext.prototype.optconstrfromtable = function() { + return this.getTypedRuleContext(OptconstrfromtableContext,0); +}; + +CreatetrigstmtContext.prototype.constraintattributespec = function() { + return this.getTypedRuleContext(ConstraintattributespecContext,0); +}; + +CreatetrigstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +CreatetrigstmtContext.prototype.EACH = function() { + return this.getToken(PostgreSQLParser.EACH, 0); +}; + +CreatetrigstmtContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +CreatetrigstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatetrigstmt(this); + } +}; + +CreatetrigstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatetrigstmt(this); + } +}; + +CreatetrigstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatetrigstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatetrigstmtContext = CreatetrigstmtContext; + +PostgreSQLParser.prototype.createtrigstmt = function() { + + var localctx = new CreatetrigstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 404, PostgreSQLParser.RULE_createtrigstmt); + try { + this.state = 3919; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,179,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3881; + this.match(PostgreSQLParser.CREATE); + this.state = 3882; + this.match(PostgreSQLParser.TRIGGER); + this.state = 3883; + this.name(); + this.state = 3884; + this.triggeractiontime(); + this.state = 3885; + this.triggerevents(); + this.state = 3886; + this.match(PostgreSQLParser.ON); + this.state = 3887; + this.qualified_name(); + this.state = 3888; + this.triggerreferencing(); + this.state = 3889; + this.triggerforspec(); + this.state = 3890; + this.triggerwhen(); + this.state = 3891; + this.match(PostgreSQLParser.EXECUTE); + this.state = 3892; + this.function_or_procedure(); + this.state = 3893; + this.func_name(); + this.state = 3894; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3895; + this.triggerfuncargs(); + this.state = 3896; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3898; + this.match(PostgreSQLParser.CREATE); + this.state = 3899; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 3900; + this.match(PostgreSQLParser.TRIGGER); + this.state = 3901; + this.name(); + this.state = 3902; + this.match(PostgreSQLParser.AFTER); + this.state = 3903; + this.triggerevents(); + this.state = 3904; + this.match(PostgreSQLParser.ON); + this.state = 3905; + this.qualified_name(); + this.state = 3906; + this.optconstrfromtable(); + this.state = 3907; + this.constraintattributespec(); + this.state = 3908; + this.match(PostgreSQLParser.FOR); + this.state = 3909; + this.match(PostgreSQLParser.EACH); + this.state = 3910; + this.match(PostgreSQLParser.ROW); + this.state = 3911; + this.triggerwhen(); + this.state = 3912; + this.match(PostgreSQLParser.EXECUTE); + this.state = 3913; + this.function_or_procedure(); + this.state = 3914; + this.func_name(); + this.state = 3915; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3916; + this.triggerfuncargs(); + this.state = 3917; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggeractiontimeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggeractiontime; + return this; +} + +TriggeractiontimeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggeractiontimeContext.prototype.constructor = TriggeractiontimeContext; + +TriggeractiontimeContext.prototype.BEFORE = function() { + return this.getToken(PostgreSQLParser.BEFORE, 0); +}; + +TriggeractiontimeContext.prototype.AFTER = function() { + return this.getToken(PostgreSQLParser.AFTER, 0); +}; + +TriggeractiontimeContext.prototype.INSTEAD = function() { + return this.getToken(PostgreSQLParser.INSTEAD, 0); +}; + +TriggeractiontimeContext.prototype.OF = function() { + return this.getToken(PostgreSQLParser.OF, 0); +}; + +TriggeractiontimeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggeractiontime(this); + } +}; + +TriggeractiontimeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggeractiontime(this); + } +}; + +TriggeractiontimeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggeractiontime(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggeractiontimeContext = TriggeractiontimeContext; + +PostgreSQLParser.prototype.triggeractiontime = function() { + + var localctx = new TriggeractiontimeContext(this, this._ctx, this.state); + this.enterRule(localctx, 406, PostgreSQLParser.RULE_triggeractiontime); + try { + this.state = 3925; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.BEFORE: + this.enterOuterAlt(localctx, 1); + this.state = 3921; + this.match(PostgreSQLParser.BEFORE); + break; + case PostgreSQLParser.AFTER: + this.enterOuterAlt(localctx, 2); + this.state = 3922; + this.match(PostgreSQLParser.AFTER); + break; + case PostgreSQLParser.INSTEAD: + this.enterOuterAlt(localctx, 3); + this.state = 3923; + this.match(PostgreSQLParser.INSTEAD); + this.state = 3924; + this.match(PostgreSQLParser.OF); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggereventsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggerevents; + return this; +} + +TriggereventsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggereventsContext.prototype.constructor = TriggereventsContext; + +TriggereventsContext.prototype.triggeroneevent = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TriggeroneeventContext); + } else { + return this.getTypedRuleContext(TriggeroneeventContext,i); + } +}; + +TriggereventsContext.prototype.OR = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.OR); + } else { + return this.getToken(PostgreSQLParser.OR, i); + } +}; + + +TriggereventsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggerevents(this); + } +}; + +TriggereventsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggerevents(this); + } +}; + +TriggereventsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggerevents(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggereventsContext = TriggereventsContext; + +PostgreSQLParser.prototype.triggerevents = function() { + + var localctx = new TriggereventsContext(this, this._ctx, this.state); + this.enterRule(localctx, 408, PostgreSQLParser.RULE_triggerevents); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3927; + this.triggeroneevent(); + this.state = 3932; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.OR) { + this.state = 3928; + this.match(PostgreSQLParser.OR); + this.state = 3929; + this.triggeroneevent(); + this.state = 3934; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggeroneeventContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggeroneevent; + return this; +} + +TriggeroneeventContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggeroneeventContext.prototype.constructor = TriggeroneeventContext; + +TriggeroneeventContext.prototype.INSERT = function() { + return this.getToken(PostgreSQLParser.INSERT, 0); +}; + +TriggeroneeventContext.prototype.DELETE_P = function() { + return this.getToken(PostgreSQLParser.DELETE_P, 0); +}; + +TriggeroneeventContext.prototype.UPDATE = function() { + return this.getToken(PostgreSQLParser.UPDATE, 0); +}; + +TriggeroneeventContext.prototype.OF = function() { + return this.getToken(PostgreSQLParser.OF, 0); +}; + +TriggeroneeventContext.prototype.columnlist = function() { + return this.getTypedRuleContext(ColumnlistContext,0); +}; + +TriggeroneeventContext.prototype.TRUNCATE = function() { + return this.getToken(PostgreSQLParser.TRUNCATE, 0); +}; + +TriggeroneeventContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggeroneevent(this); + } +}; + +TriggeroneeventContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggeroneevent(this); + } +}; + +TriggeroneeventContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggeroneevent(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggeroneeventContext = TriggeroneeventContext; + +PostgreSQLParser.prototype.triggeroneevent = function() { + + var localctx = new TriggeroneeventContext(this, this._ctx, this.state); + this.enterRule(localctx, 410, PostgreSQLParser.RULE_triggeroneevent); + try { + this.state = 3942; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,182,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 3935; + this.match(PostgreSQLParser.INSERT); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 3936; + this.match(PostgreSQLParser.DELETE_P); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 3937; + this.match(PostgreSQLParser.UPDATE); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 3938; + this.match(PostgreSQLParser.UPDATE); + this.state = 3939; + this.match(PostgreSQLParser.OF); + this.state = 3940; + this.columnlist(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 3941; + this.match(PostgreSQLParser.TRUNCATE); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggerreferencingContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggerreferencing; + return this; +} + +TriggerreferencingContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggerreferencingContext.prototype.constructor = TriggerreferencingContext; + +TriggerreferencingContext.prototype.REFERENCING = function() { + return this.getToken(PostgreSQLParser.REFERENCING, 0); +}; + +TriggerreferencingContext.prototype.triggertransitions = function() { + return this.getTypedRuleContext(TriggertransitionsContext,0); +}; + +TriggerreferencingContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggerreferencing(this); + } +}; + +TriggerreferencingContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggerreferencing(this); + } +}; + +TriggerreferencingContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggerreferencing(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggerreferencingContext = TriggerreferencingContext; + +PostgreSQLParser.prototype.triggerreferencing = function() { + + var localctx = new TriggerreferencingContext(this, this._ctx, this.state); + this.enterRule(localctx, 412, PostgreSQLParser.RULE_triggerreferencing); + try { + this.state = 3947; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.REFERENCING: + this.enterOuterAlt(localctx, 1); + this.state = 3944; + this.match(PostgreSQLParser.REFERENCING); + this.state = 3945; + this.triggertransitions(); + break; + case PostgreSQLParser.FOR: + case PostgreSQLParser.WHEN: + case PostgreSQLParser.EXECUTE: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggertransitionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggertransitions; + return this; +} + +TriggertransitionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggertransitionsContext.prototype.constructor = TriggertransitionsContext; + +TriggertransitionsContext.prototype.triggertransition = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TriggertransitionContext); + } else { + return this.getTypedRuleContext(TriggertransitionContext,i); + } +}; + +TriggertransitionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggertransitions(this); + } +}; + +TriggertransitionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggertransitions(this); + } +}; + +TriggertransitionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggertransitions(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggertransitionsContext = TriggertransitionsContext; + +PostgreSQLParser.prototype.triggertransitions = function() { + + var localctx = new TriggertransitionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 414, PostgreSQLParser.RULE_triggertransitions); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3950; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + this.state = 3949; + this.triggertransition(); + this.state = 3952; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while(_la===PostgreSQLParser.NEW || _la===PostgreSQLParser.OLD); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggertransitionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggertransition; + return this; +} + +TriggertransitionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggertransitionContext.prototype.constructor = TriggertransitionContext; + +TriggertransitionContext.prototype.transitionoldornew = function() { + return this.getTypedRuleContext(TransitionoldornewContext,0); +}; + +TriggertransitionContext.prototype.transitionrowortable = function() { + return this.getTypedRuleContext(TransitionrowortableContext,0); +}; + +TriggertransitionContext.prototype.opt_as = function() { + return this.getTypedRuleContext(Opt_asContext,0); +}; + +TriggertransitionContext.prototype.transitionrelname = function() { + return this.getTypedRuleContext(TransitionrelnameContext,0); +}; + +TriggertransitionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggertransition(this); + } +}; + +TriggertransitionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggertransition(this); + } +}; + +TriggertransitionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggertransition(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggertransitionContext = TriggertransitionContext; + +PostgreSQLParser.prototype.triggertransition = function() { + + var localctx = new TriggertransitionContext(this, this._ctx, this.state); + this.enterRule(localctx, 416, PostgreSQLParser.RULE_triggertransition); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3954; + this.transitionoldornew(); + this.state = 3955; + this.transitionrowortable(); + this.state = 3956; + this.opt_as(); + this.state = 3957; + this.transitionrelname(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TransitionoldornewContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_transitionoldornew; + return this; +} + +TransitionoldornewContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TransitionoldornewContext.prototype.constructor = TransitionoldornewContext; + +TransitionoldornewContext.prototype.NEW = function() { + return this.getToken(PostgreSQLParser.NEW, 0); +}; + +TransitionoldornewContext.prototype.OLD = function() { + return this.getToken(PostgreSQLParser.OLD, 0); +}; + +TransitionoldornewContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTransitionoldornew(this); + } +}; + +TransitionoldornewContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTransitionoldornew(this); + } +}; + +TransitionoldornewContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTransitionoldornew(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TransitionoldornewContext = TransitionoldornewContext; + +PostgreSQLParser.prototype.transitionoldornew = function() { + + var localctx = new TransitionoldornewContext(this, this._ctx, this.state); + this.enterRule(localctx, 418, PostgreSQLParser.RULE_transitionoldornew); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3959; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.NEW || _la===PostgreSQLParser.OLD)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TransitionrowortableContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_transitionrowortable; + return this; +} + +TransitionrowortableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TransitionrowortableContext.prototype.constructor = TransitionrowortableContext; + +TransitionrowortableContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +TransitionrowortableContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +TransitionrowortableContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTransitionrowortable(this); + } +}; + +TransitionrowortableContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTransitionrowortable(this); + } +}; + +TransitionrowortableContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTransitionrowortable(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TransitionrowortableContext = TransitionrowortableContext; + +PostgreSQLParser.prototype.transitionrowortable = function() { + + var localctx = new TransitionrowortableContext(this, this._ctx, this.state); + this.enterRule(localctx, 420, PostgreSQLParser.RULE_transitionrowortable); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3961; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.TABLE || _la===PostgreSQLParser.ROW)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TransitionrelnameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_transitionrelname; + return this; +} + +TransitionrelnameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TransitionrelnameContext.prototype.constructor = TransitionrelnameContext; + +TransitionrelnameContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +TransitionrelnameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTransitionrelname(this); + } +}; + +TransitionrelnameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTransitionrelname(this); + } +}; + +TransitionrelnameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTransitionrelname(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TransitionrelnameContext = TransitionrelnameContext; + +PostgreSQLParser.prototype.transitionrelname = function() { + + var localctx = new TransitionrelnameContext(this, this._ctx, this.state); + this.enterRule(localctx, 422, PostgreSQLParser.RULE_transitionrelname); + try { + this.enterOuterAlt(localctx, 1); + this.state = 3963; + this.colid(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggerforspecContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggerforspec; + return this; +} + +TriggerforspecContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggerforspecContext.prototype.constructor = TriggerforspecContext; + +TriggerforspecContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +TriggerforspecContext.prototype.triggerforopteach = function() { + return this.getTypedRuleContext(TriggerforopteachContext,0); +}; + +TriggerforspecContext.prototype.triggerfortype = function() { + return this.getTypedRuleContext(TriggerfortypeContext,0); +}; + +TriggerforspecContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggerforspec(this); + } +}; + +TriggerforspecContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggerforspec(this); + } +}; + +TriggerforspecContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggerforspec(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggerforspecContext = TriggerforspecContext; + +PostgreSQLParser.prototype.triggerforspec = function() { + + var localctx = new TriggerforspecContext(this, this._ctx, this.state); + this.enterRule(localctx, 424, PostgreSQLParser.RULE_triggerforspec); + try { + this.state = 3970; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FOR: + this.enterOuterAlt(localctx, 1); + this.state = 3965; + this.match(PostgreSQLParser.FOR); + this.state = 3966; + this.triggerforopteach(); + this.state = 3967; + this.triggerfortype(); + break; + case PostgreSQLParser.WHEN: + case PostgreSQLParser.EXECUTE: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggerforopteachContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggerforopteach; + return this; +} + +TriggerforopteachContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggerforopteachContext.prototype.constructor = TriggerforopteachContext; + +TriggerforopteachContext.prototype.EACH = function() { + return this.getToken(PostgreSQLParser.EACH, 0); +}; + +TriggerforopteachContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggerforopteach(this); + } +}; + +TriggerforopteachContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggerforopteach(this); + } +}; + +TriggerforopteachContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggerforopteach(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggerforopteachContext = TriggerforopteachContext; + +PostgreSQLParser.prototype.triggerforopteach = function() { + + var localctx = new TriggerforopteachContext(this, this._ctx, this.state); + this.enterRule(localctx, 426, PostgreSQLParser.RULE_triggerforopteach); + try { + this.state = 3974; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.EACH: + this.enterOuterAlt(localctx, 1); + this.state = 3972; + this.match(PostgreSQLParser.EACH); + break; + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.ROW: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggerfortypeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggerfortype; + return this; +} + +TriggerfortypeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggerfortypeContext.prototype.constructor = TriggerfortypeContext; + +TriggerfortypeContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +TriggerfortypeContext.prototype.STATEMENT = function() { + return this.getToken(PostgreSQLParser.STATEMENT, 0); +}; + +TriggerfortypeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggerfortype(this); + } +}; + +TriggerfortypeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggerfortype(this); + } +}; + +TriggerfortypeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggerfortype(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggerfortypeContext = TriggerfortypeContext; + +PostgreSQLParser.prototype.triggerfortype = function() { + + var localctx = new TriggerfortypeContext(this, this._ctx, this.state); + this.enterRule(localctx, 428, PostgreSQLParser.RULE_triggerfortype); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3976; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.STATEMENT || _la===PostgreSQLParser.ROW)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggerwhenContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggerwhen; + return this; +} + +TriggerwhenContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggerwhenContext.prototype.constructor = TriggerwhenContext; + +TriggerwhenContext.prototype.WHEN = function() { + return this.getToken(PostgreSQLParser.WHEN, 0); +}; + +TriggerwhenContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +TriggerwhenContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +TriggerwhenContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +TriggerwhenContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggerwhen(this); + } +}; + +TriggerwhenContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggerwhen(this); + } +}; + +TriggerwhenContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggerwhen(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggerwhenContext = TriggerwhenContext; + +PostgreSQLParser.prototype.triggerwhen = function() { + + var localctx = new TriggerwhenContext(this, this._ctx, this.state); + this.enterRule(localctx, 430, PostgreSQLParser.RULE_triggerwhen); + try { + this.state = 3984; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.WHEN: + this.enterOuterAlt(localctx, 1); + this.state = 3978; + this.match(PostgreSQLParser.WHEN); + this.state = 3979; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 3980; + this.a_expr(); + this.state = 3981; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.EXECUTE: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Function_or_procedureContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_function_or_procedure; + return this; +} + +Function_or_procedureContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Function_or_procedureContext.prototype.constructor = Function_or_procedureContext; + +Function_or_procedureContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +Function_or_procedureContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +Function_or_procedureContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunction_or_procedure(this); + } +}; + +Function_or_procedureContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunction_or_procedure(this); + } +}; + +Function_or_procedureContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunction_or_procedure(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Function_or_procedureContext = Function_or_procedureContext; + +PostgreSQLParser.prototype.function_or_procedure = function() { + + var localctx = new Function_or_procedureContext(this, this._ctx, this.state); + this.enterRule(localctx, 432, PostgreSQLParser.RULE_function_or_procedure); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3986; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FUNCTION || _la===PostgreSQLParser.PROCEDURE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggerfuncargsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggerfuncargs; + return this; +} + +TriggerfuncargsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggerfuncargsContext.prototype.constructor = TriggerfuncargsContext; + +TriggerfuncargsContext.prototype.triggerfuncarg = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TriggerfuncargContext); + } else { + return this.getTypedRuleContext(TriggerfuncargContext,i); + } +}; + +TriggerfuncargsContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +TriggerfuncargsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggerfuncargs(this); + } +}; + +TriggerfuncargsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggerfuncargs(this); + } +}; + +TriggerfuncargsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggerfuncargs(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggerfuncargsContext = TriggerfuncargsContext; + +PostgreSQLParser.prototype.triggerfuncargs = function() { + + var localctx = new TriggerfuncargsContext(this, this._ctx, this.state); + this.enterRule(localctx, 434, PostgreSQLParser.RULE_triggerfuncargs); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 3990; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ALL: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AND: + case PostgreSQLParser.ANY: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.AS: + case PostgreSQLParser.ASC: + case PostgreSQLParser.ASYMMETRIC: + case PostgreSQLParser.BOTH: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.CHECK: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.DESC: + case PostgreSQLParser.DISTINCT: + case PostgreSQLParser.DO: + case PostgreSQLParser.ELSE: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.FOREIGN: + case PostgreSQLParser.FROM: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.GROUP_P: + case PostgreSQLParser.HAVING: + case PostgreSQLParser.IN_P: + case PostgreSQLParser.INITIALLY: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.LATERAL_P: + case PostgreSQLParser.LEADING: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ONLY: + case PostgreSQLParser.OR: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.PLACING: + case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.REFERENCES: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.SOME: + case PostgreSQLParser.SYMMETRIC: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.THEN: + case PostgreSQLParser.TO: + case PostgreSQLParser.TRAILING: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNION: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.USING: + case PostgreSQLParser.VARIADIC: + case PostgreSQLParser.WHEN: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.state = 3988; + this.triggerfuncarg(); + break; + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 3996; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 3992; + this.match(PostgreSQLParser.COMMA); + this.state = 3993; + this.triggerfuncarg(); + this.state = 3998; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TriggerfuncargContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_triggerfuncarg; + return this; +} + +TriggerfuncargContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TriggerfuncargContext.prototype.constructor = TriggerfuncargContext; + +TriggerfuncargContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +TriggerfuncargContext.prototype.fconst = function() { + return this.getTypedRuleContext(FconstContext,0); +}; + +TriggerfuncargContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +TriggerfuncargContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +TriggerfuncargContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTriggerfuncarg(this); + } +}; + +TriggerfuncargContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTriggerfuncarg(this); + } +}; + +TriggerfuncargContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTriggerfuncarg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TriggerfuncargContext = TriggerfuncargContext; + +PostgreSQLParser.prototype.triggerfuncarg = function() { + + var localctx = new TriggerfuncargContext(this, this._ctx, this.state); + this.enterRule(localctx, 436, PostgreSQLParser.RULE_triggerfuncarg); + try { + this.state = 4003; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.Integral: + this.enterOuterAlt(localctx, 1); + this.state = 3999; + this.iconst(); + break; + case PostgreSQLParser.Numeric: + this.enterOuterAlt(localctx, 2); + this.state = 4000; + this.fconst(); + break; + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 3); + this.state = 4001; + this.sconst(); + break; + case PostgreSQLParser.ALL: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AND: + case PostgreSQLParser.ANY: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.AS: + case PostgreSQLParser.ASC: + case PostgreSQLParser.ASYMMETRIC: + case PostgreSQLParser.BOTH: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.CHECK: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.DESC: + case PostgreSQLParser.DISTINCT: + case PostgreSQLParser.DO: + case PostgreSQLParser.ELSE: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.FOREIGN: + case PostgreSQLParser.FROM: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.GROUP_P: + case PostgreSQLParser.HAVING: + case PostgreSQLParser.IN_P: + case PostgreSQLParser.INITIALLY: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.LATERAL_P: + case PostgreSQLParser.LEADING: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ONLY: + case PostgreSQLParser.OR: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.PLACING: + case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.REFERENCES: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.SOME: + case PostgreSQLParser.SYMMETRIC: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.THEN: + case PostgreSQLParser.TO: + case PostgreSQLParser.TRAILING: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNION: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.USING: + case PostgreSQLParser.VARIADIC: + case PostgreSQLParser.WHEN: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 4); + this.state = 4002; + this.collabel(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OptconstrfromtableContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_optconstrfromtable; + return this; +} + +OptconstrfromtableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OptconstrfromtableContext.prototype.constructor = OptconstrfromtableContext; + +OptconstrfromtableContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +OptconstrfromtableContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +OptconstrfromtableContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOptconstrfromtable(this); + } +}; + +OptconstrfromtableContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOptconstrfromtable(this); + } +}; + +OptconstrfromtableContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOptconstrfromtable(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OptconstrfromtableContext = OptconstrfromtableContext; + +PostgreSQLParser.prototype.optconstrfromtable = function() { + + var localctx = new OptconstrfromtableContext(this, this._ctx, this.state); + this.enterRule(localctx, 438, PostgreSQLParser.RULE_optconstrfromtable); + try { + this.state = 4008; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FROM: + this.enterOuterAlt(localctx, 1); + this.state = 4005; + this.match(PostgreSQLParser.FROM); + this.state = 4006; + this.qualified_name(); + break; + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.FOR: + case PostgreSQLParser.INITIALLY: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NO: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ConstraintattributespecContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constraintattributespec; + return this; +} + +ConstraintattributespecContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ConstraintattributespecContext.prototype.constructor = ConstraintattributespecContext; + +ConstraintattributespecContext.prototype.constraintattributeElem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(ConstraintattributeElemContext); + } else { + return this.getTypedRuleContext(ConstraintattributeElemContext,i); + } +}; + +ConstraintattributespecContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstraintattributespec(this); + } +}; + +ConstraintattributespecContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstraintattributespec(this); + } +}; + +ConstraintattributespecContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstraintattributespec(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ConstraintattributespecContext = ConstraintattributespecContext; + +PostgreSQLParser.prototype.constraintattributespec = function() { + + var localctx = new ConstraintattributespecContext(this, this._ctx, this.state); + this.enterRule(localctx, 440, PostgreSQLParser.RULE_constraintattributespec); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4013; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(((((_la - 54)) & ~0x1f) == 0 && ((1 << (_la - 54)) & ((1 << (PostgreSQLParser.DEFERRABLE - 54)) | (1 << (PostgreSQLParser.INITIALLY - 54)) | (1 << (PostgreSQLParser.NOT - 54)))) !== 0) || _la===PostgreSQLParser.NO) { + this.state = 4010; + this.constraintattributeElem(); + this.state = 4015; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ConstraintattributeElemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constraintattributeElem; + return this; +} + +ConstraintattributeElemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ConstraintattributeElemContext.prototype.constructor = ConstraintattributeElemContext; + +ConstraintattributeElemContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +ConstraintattributeElemContext.prototype.DEFERRABLE = function() { + return this.getToken(PostgreSQLParser.DEFERRABLE, 0); +}; + +ConstraintattributeElemContext.prototype.INITIALLY = function() { + return this.getToken(PostgreSQLParser.INITIALLY, 0); +}; + +ConstraintattributeElemContext.prototype.IMMEDIATE = function() { + return this.getToken(PostgreSQLParser.IMMEDIATE, 0); +}; + +ConstraintattributeElemContext.prototype.DEFERRED = function() { + return this.getToken(PostgreSQLParser.DEFERRED, 0); +}; + +ConstraintattributeElemContext.prototype.VALID = function() { + return this.getToken(PostgreSQLParser.VALID, 0); +}; + +ConstraintattributeElemContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +ConstraintattributeElemContext.prototype.INHERIT = function() { + return this.getToken(PostgreSQLParser.INHERIT, 0); +}; + +ConstraintattributeElemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstraintattributeElem(this); + } +}; + +ConstraintattributeElemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstraintattributeElem(this); + } +}; + +ConstraintattributeElemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstraintattributeElem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ConstraintattributeElemContext = ConstraintattributeElemContext; + +PostgreSQLParser.prototype.constraintattributeElem = function() { + + var localctx = new ConstraintattributeElemContext(this, this._ctx, this.state); + this.enterRule(localctx, 442, PostgreSQLParser.RULE_constraintattributeElem); + try { + this.state = 4027; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,193,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4016; + this.match(PostgreSQLParser.NOT); + this.state = 4017; + this.match(PostgreSQLParser.DEFERRABLE); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4018; + this.match(PostgreSQLParser.DEFERRABLE); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4019; + this.match(PostgreSQLParser.INITIALLY); + this.state = 4020; + this.match(PostgreSQLParser.IMMEDIATE); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4021; + this.match(PostgreSQLParser.INITIALLY); + this.state = 4022; + this.match(PostgreSQLParser.DEFERRED); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 4023; + this.match(PostgreSQLParser.NOT); + this.state = 4024; + this.match(PostgreSQLParser.VALID); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 4025; + this.match(PostgreSQLParser.NO); + this.state = 4026; + this.match(PostgreSQLParser.INHERIT); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateeventtrigstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createeventtrigstmt; + return this; +} + +CreateeventtrigstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateeventtrigstmtContext.prototype.constructor = CreateeventtrigstmtContext; + +CreateeventtrigstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateeventtrigstmtContext.prototype.EVENT = function() { + return this.getToken(PostgreSQLParser.EVENT, 0); +}; + +CreateeventtrigstmtContext.prototype.TRIGGER = function() { + return this.getToken(PostgreSQLParser.TRIGGER, 0); +}; + +CreateeventtrigstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreateeventtrigstmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +CreateeventtrigstmtContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +CreateeventtrigstmtContext.prototype.EXECUTE = function() { + return this.getToken(PostgreSQLParser.EXECUTE, 0); +}; + +CreateeventtrigstmtContext.prototype.function_or_procedure = function() { + return this.getTypedRuleContext(Function_or_procedureContext,0); +}; + +CreateeventtrigstmtContext.prototype.func_name = function() { + return this.getTypedRuleContext(Func_nameContext,0); +}; + +CreateeventtrigstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CreateeventtrigstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CreateeventtrigstmtContext.prototype.WHEN = function() { + return this.getToken(PostgreSQLParser.WHEN, 0); +}; + +CreateeventtrigstmtContext.prototype.event_trigger_when_list = function() { + return this.getTypedRuleContext(Event_trigger_when_listContext,0); +}; + +CreateeventtrigstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateeventtrigstmt(this); + } +}; + +CreateeventtrigstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateeventtrigstmt(this); + } +}; + +CreateeventtrigstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateeventtrigstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateeventtrigstmtContext = CreateeventtrigstmtContext; + +PostgreSQLParser.prototype.createeventtrigstmt = function() { + + var localctx = new CreateeventtrigstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 444, PostgreSQLParser.RULE_createeventtrigstmt); + try { + this.state = 4055; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,194,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4029; + this.match(PostgreSQLParser.CREATE); + this.state = 4030; + this.match(PostgreSQLParser.EVENT); + this.state = 4031; + this.match(PostgreSQLParser.TRIGGER); + this.state = 4032; + this.name(); + this.state = 4033; + this.match(PostgreSQLParser.ON); + this.state = 4034; + this.collabel(); + this.state = 4035; + this.match(PostgreSQLParser.EXECUTE); + this.state = 4036; + this.function_or_procedure(); + this.state = 4037; + this.func_name(); + this.state = 4038; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4039; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4041; + this.match(PostgreSQLParser.CREATE); + this.state = 4042; + this.match(PostgreSQLParser.EVENT); + this.state = 4043; + this.match(PostgreSQLParser.TRIGGER); + this.state = 4044; + this.name(); + this.state = 4045; + this.match(PostgreSQLParser.ON); + this.state = 4046; + this.collabel(); + this.state = 4047; + this.match(PostgreSQLParser.WHEN); + this.state = 4048; + this.event_trigger_when_list(); + this.state = 4049; + this.match(PostgreSQLParser.EXECUTE); + this.state = 4050; + this.function_or_procedure(); + this.state = 4051; + this.func_name(); + this.state = 4052; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4053; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Event_trigger_when_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_event_trigger_when_list; + return this; +} + +Event_trigger_when_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Event_trigger_when_listContext.prototype.constructor = Event_trigger_when_listContext; + +Event_trigger_when_listContext.prototype.event_trigger_when_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Event_trigger_when_itemContext); + } else { + return this.getTypedRuleContext(Event_trigger_when_itemContext,i); + } +}; + +Event_trigger_when_listContext.prototype.AND = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.AND); + } else { + return this.getToken(PostgreSQLParser.AND, i); + } +}; + + +Event_trigger_when_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterEvent_trigger_when_list(this); + } +}; + +Event_trigger_when_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitEvent_trigger_when_list(this); + } +}; + +Event_trigger_when_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitEvent_trigger_when_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Event_trigger_when_listContext = Event_trigger_when_listContext; + +PostgreSQLParser.prototype.event_trigger_when_list = function() { + + var localctx = new Event_trigger_when_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 446, PostgreSQLParser.RULE_event_trigger_when_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4057; + this.event_trigger_when_item(); + this.state = 4062; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.AND) { + this.state = 4058; + this.match(PostgreSQLParser.AND); + this.state = 4059; + this.event_trigger_when_item(); + this.state = 4064; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Event_trigger_when_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_event_trigger_when_item; + return this; +} + +Event_trigger_when_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Event_trigger_when_itemContext.prototype.constructor = Event_trigger_when_itemContext; + +Event_trigger_when_itemContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Event_trigger_when_itemContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +Event_trigger_when_itemContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Event_trigger_when_itemContext.prototype.event_trigger_value_list = function() { + return this.getTypedRuleContext(Event_trigger_value_listContext,0); +}; + +Event_trigger_when_itemContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Event_trigger_when_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterEvent_trigger_when_item(this); + } +}; + +Event_trigger_when_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitEvent_trigger_when_item(this); + } +}; + +Event_trigger_when_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitEvent_trigger_when_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Event_trigger_when_itemContext = Event_trigger_when_itemContext; + +PostgreSQLParser.prototype.event_trigger_when_item = function() { + + var localctx = new Event_trigger_when_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 448, PostgreSQLParser.RULE_event_trigger_when_item); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4065; + this.colid(); + this.state = 4066; + this.match(PostgreSQLParser.IN_P); + this.state = 4067; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4068; + this.event_trigger_value_list(); + this.state = 4069; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Event_trigger_value_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_event_trigger_value_list; + return this; +} + +Event_trigger_value_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Event_trigger_value_listContext.prototype.constructor = Event_trigger_value_listContext; + +Event_trigger_value_listContext.prototype.sconst = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(SconstContext); + } else { + return this.getTypedRuleContext(SconstContext,i); + } +}; + +Event_trigger_value_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Event_trigger_value_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterEvent_trigger_value_list(this); + } +}; + +Event_trigger_value_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitEvent_trigger_value_list(this); + } +}; + +Event_trigger_value_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitEvent_trigger_value_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Event_trigger_value_listContext = Event_trigger_value_listContext; + +PostgreSQLParser.prototype.event_trigger_value_list = function() { + + var localctx = new Event_trigger_value_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 450, PostgreSQLParser.RULE_event_trigger_value_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4071; + this.sconst(); + this.state = 4076; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 4072; + this.match(PostgreSQLParser.COMMA); + this.state = 4073; + this.sconst(); + this.state = 4078; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltereventtrigstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altereventtrigstmt; + return this; +} + +AltereventtrigstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltereventtrigstmtContext.prototype.constructor = AltereventtrigstmtContext; + +AltereventtrigstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AltereventtrigstmtContext.prototype.EVENT = function() { + return this.getToken(PostgreSQLParser.EVENT, 0); +}; + +AltereventtrigstmtContext.prototype.TRIGGER = function() { + return this.getToken(PostgreSQLParser.TRIGGER, 0); +}; + +AltereventtrigstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AltereventtrigstmtContext.prototype.enable_trigger = function() { + return this.getTypedRuleContext(Enable_triggerContext,0); +}; + +AltereventtrigstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltereventtrigstmt(this); + } +}; + +AltereventtrigstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltereventtrigstmt(this); + } +}; + +AltereventtrigstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltereventtrigstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltereventtrigstmtContext = AltereventtrigstmtContext; + +PostgreSQLParser.prototype.altereventtrigstmt = function() { + + var localctx = new AltereventtrigstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 452, PostgreSQLParser.RULE_altereventtrigstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4079; + this.match(PostgreSQLParser.ALTER); + this.state = 4080; + this.match(PostgreSQLParser.EVENT); + this.state = 4081; + this.match(PostgreSQLParser.TRIGGER); + this.state = 4082; + this.name(); + this.state = 4083; + this.enable_trigger(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Enable_triggerContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_enable_trigger; + return this; +} + +Enable_triggerContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Enable_triggerContext.prototype.constructor = Enable_triggerContext; + +Enable_triggerContext.prototype.ENABLE_P = function() { + return this.getToken(PostgreSQLParser.ENABLE_P, 0); +}; + +Enable_triggerContext.prototype.REPLICA = function() { + return this.getToken(PostgreSQLParser.REPLICA, 0); +}; + +Enable_triggerContext.prototype.ALWAYS = function() { + return this.getToken(PostgreSQLParser.ALWAYS, 0); +}; + +Enable_triggerContext.prototype.DISABLE_P = function() { + return this.getToken(PostgreSQLParser.DISABLE_P, 0); +}; + +Enable_triggerContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterEnable_trigger(this); + } +}; + +Enable_triggerContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitEnable_trigger(this); + } +}; + +Enable_triggerContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitEnable_trigger(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Enable_triggerContext = Enable_triggerContext; + +PostgreSQLParser.prototype.enable_trigger = function() { + + var localctx = new Enable_triggerContext(this, this._ctx, this.state); + this.enterRule(localctx, 454, PostgreSQLParser.RULE_enable_trigger); + try { + this.state = 4091; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,197,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4085; + this.match(PostgreSQLParser.ENABLE_P); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4086; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 4087; + this.match(PostgreSQLParser.REPLICA); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4088; + this.match(PostgreSQLParser.ENABLE_P); + this.state = 4089; + this.match(PostgreSQLParser.ALWAYS); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4090; + this.match(PostgreSQLParser.DISABLE_P); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateassertionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createassertionstmt; + return this; +} + +CreateassertionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateassertionstmtContext.prototype.constructor = CreateassertionstmtContext; + +CreateassertionstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateassertionstmtContext.prototype.ASSERTION = function() { + return this.getToken(PostgreSQLParser.ASSERTION, 0); +}; + +CreateassertionstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +CreateassertionstmtContext.prototype.CHECK = function() { + return this.getToken(PostgreSQLParser.CHECK, 0); +}; + +CreateassertionstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CreateassertionstmtContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +CreateassertionstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CreateassertionstmtContext.prototype.constraintattributespec = function() { + return this.getTypedRuleContext(ConstraintattributespecContext,0); +}; + +CreateassertionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateassertionstmt(this); + } +}; + +CreateassertionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateassertionstmt(this); + } +}; + +CreateassertionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateassertionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateassertionstmtContext = CreateassertionstmtContext; + +PostgreSQLParser.prototype.createassertionstmt = function() { + + var localctx = new CreateassertionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 456, PostgreSQLParser.RULE_createassertionstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4093; + this.match(PostgreSQLParser.CREATE); + this.state = 4094; + this.match(PostgreSQLParser.ASSERTION); + this.state = 4095; + this.any_name(); + this.state = 4096; + this.match(PostgreSQLParser.CHECK); + this.state = 4097; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4098; + this.a_expr(); + this.state = 4099; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 4100; + this.constraintattributespec(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DefinestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_definestmt; + return this; +} + +DefinestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DefinestmtContext.prototype.constructor = DefinestmtContext; + +DefinestmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +DefinestmtContext.prototype.opt_or_replace = function() { + return this.getTypedRuleContext(Opt_or_replaceContext,0); +}; + +DefinestmtContext.prototype.AGGREGATE = function() { + return this.getToken(PostgreSQLParser.AGGREGATE, 0); +}; + +DefinestmtContext.prototype.func_name = function() { + return this.getTypedRuleContext(Func_nameContext,0); +}; + +DefinestmtContext.prototype.aggr_args = function() { + return this.getTypedRuleContext(Aggr_argsContext,0); +}; + +DefinestmtContext.prototype.definition = function() { + return this.getTypedRuleContext(DefinitionContext,0); +}; + +DefinestmtContext.prototype.old_aggr_definition = function() { + return this.getTypedRuleContext(Old_aggr_definitionContext,0); +}; + +DefinestmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +DefinestmtContext.prototype.any_operator = function() { + return this.getTypedRuleContext(Any_operatorContext,0); +}; + +DefinestmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +DefinestmtContext.prototype.any_name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Any_nameContext); + } else { + return this.getTypedRuleContext(Any_nameContext,i); + } +}; + +DefinestmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +DefinestmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +DefinestmtContext.prototype.opttablefuncelementlist = function() { + return this.getTypedRuleContext(OpttablefuncelementlistContext,0); +}; + +DefinestmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +DefinestmtContext.prototype.ENUM_P = function() { + return this.getToken(PostgreSQLParser.ENUM_P, 0); +}; + +DefinestmtContext.prototype.opt_enum_val_list = function() { + return this.getTypedRuleContext(Opt_enum_val_listContext,0); +}; + +DefinestmtContext.prototype.RANGE = function() { + return this.getToken(PostgreSQLParser.RANGE, 0); +}; + +DefinestmtContext.prototype.TEXT_P = function() { + return this.getToken(PostgreSQLParser.TEXT_P, 0); +}; + +DefinestmtContext.prototype.SEARCH = function() { + return this.getToken(PostgreSQLParser.SEARCH, 0); +}; + +DefinestmtContext.prototype.PARSER = function() { + return this.getToken(PostgreSQLParser.PARSER, 0); +}; + +DefinestmtContext.prototype.DICTIONARY = function() { + return this.getToken(PostgreSQLParser.DICTIONARY, 0); +}; + +DefinestmtContext.prototype.TEMPLATE = function() { + return this.getToken(PostgreSQLParser.TEMPLATE, 0); +}; + +DefinestmtContext.prototype.CONFIGURATION = function() { + return this.getToken(PostgreSQLParser.CONFIGURATION, 0); +}; + +DefinestmtContext.prototype.COLLATION = function() { + return this.getToken(PostgreSQLParser.COLLATION, 0); +}; + +DefinestmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +DefinestmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +DefinestmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +DefinestmtContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +DefinestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDefinestmt(this); + } +}; + +DefinestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDefinestmt(this); + } +}; + +DefinestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDefinestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DefinestmtContext = DefinestmtContext; + +PostgreSQLParser.prototype.definestmt = function() { + + var localctx = new DefinestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 458, PostgreSQLParser.RULE_definestmt); + try { + this.state = 4208; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,198,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4102; + this.match(PostgreSQLParser.CREATE); + this.state = 4103; + this.opt_or_replace(); + this.state = 4104; + this.match(PostgreSQLParser.AGGREGATE); + this.state = 4105; + this.func_name(); + this.state = 4106; + this.aggr_args(); + this.state = 4107; + this.definition(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4109; + this.match(PostgreSQLParser.CREATE); + this.state = 4110; + this.opt_or_replace(); + this.state = 4111; + this.match(PostgreSQLParser.AGGREGATE); + this.state = 4112; + this.func_name(); + this.state = 4113; + this.old_aggr_definition(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4115; + this.match(PostgreSQLParser.CREATE); + this.state = 4116; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4117; + this.any_operator(); + this.state = 4118; + this.definition(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4120; + this.match(PostgreSQLParser.CREATE); + this.state = 4121; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4122; + this.any_name(); + this.state = 4123; + this.definition(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 4125; + this.match(PostgreSQLParser.CREATE); + this.state = 4126; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4127; + this.any_name(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 4128; + this.match(PostgreSQLParser.CREATE); + this.state = 4129; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4130; + this.any_name(); + this.state = 4131; + this.match(PostgreSQLParser.AS); + this.state = 4132; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4133; + this.opttablefuncelementlist(); + this.state = 4134; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 4136; + this.match(PostgreSQLParser.CREATE); + this.state = 4137; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4138; + this.any_name(); + this.state = 4139; + this.match(PostgreSQLParser.AS); + this.state = 4140; + this.match(PostgreSQLParser.ENUM_P); + this.state = 4141; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4142; + this.opt_enum_val_list(); + this.state = 4143; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 4145; + this.match(PostgreSQLParser.CREATE); + this.state = 4146; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4147; + this.any_name(); + this.state = 4148; + this.match(PostgreSQLParser.AS); + this.state = 4149; + this.match(PostgreSQLParser.RANGE); + this.state = 4150; + this.definition(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 4152; + this.match(PostgreSQLParser.CREATE); + this.state = 4153; + this.match(PostgreSQLParser.TEXT_P); + this.state = 4154; + this.match(PostgreSQLParser.SEARCH); + this.state = 4155; + this.match(PostgreSQLParser.PARSER); + this.state = 4156; + this.any_name(); + this.state = 4157; + this.definition(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 4159; + this.match(PostgreSQLParser.CREATE); + this.state = 4160; + this.match(PostgreSQLParser.TEXT_P); + this.state = 4161; + this.match(PostgreSQLParser.SEARCH); + this.state = 4162; + this.match(PostgreSQLParser.DICTIONARY); + this.state = 4163; + this.any_name(); + this.state = 4164; + this.definition(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 4166; + this.match(PostgreSQLParser.CREATE); + this.state = 4167; + this.match(PostgreSQLParser.TEXT_P); + this.state = 4168; + this.match(PostgreSQLParser.SEARCH); + this.state = 4169; + this.match(PostgreSQLParser.TEMPLATE); + this.state = 4170; + this.any_name(); + this.state = 4171; + this.definition(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 4173; + this.match(PostgreSQLParser.CREATE); + this.state = 4174; + this.match(PostgreSQLParser.TEXT_P); + this.state = 4175; + this.match(PostgreSQLParser.SEARCH); + this.state = 4176; + this.match(PostgreSQLParser.CONFIGURATION); + this.state = 4177; + this.any_name(); + this.state = 4178; + this.definition(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 4180; + this.match(PostgreSQLParser.CREATE); + this.state = 4181; + this.match(PostgreSQLParser.COLLATION); + this.state = 4182; + this.any_name(); + this.state = 4183; + this.definition(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 4185; + this.match(PostgreSQLParser.CREATE); + this.state = 4186; + this.match(PostgreSQLParser.COLLATION); + this.state = 4187; + this.match(PostgreSQLParser.IF_P); + this.state = 4188; + this.match(PostgreSQLParser.NOT); + this.state = 4189; + this.match(PostgreSQLParser.EXISTS); + this.state = 4190; + this.any_name(); + this.state = 4191; + this.definition(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 4193; + this.match(PostgreSQLParser.CREATE); + this.state = 4194; + this.match(PostgreSQLParser.COLLATION); + this.state = 4195; + this.any_name(); + this.state = 4196; + this.match(PostgreSQLParser.FROM); + this.state = 4197; + this.any_name(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 4199; + this.match(PostgreSQLParser.CREATE); + this.state = 4200; + this.match(PostgreSQLParser.COLLATION); + this.state = 4201; + this.match(PostgreSQLParser.IF_P); + this.state = 4202; + this.match(PostgreSQLParser.NOT); + this.state = 4203; + this.match(PostgreSQLParser.EXISTS); + this.state = 4204; + this.any_name(); + this.state = 4205; + this.match(PostgreSQLParser.FROM); + this.state = 4206; + this.any_name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DefinitionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_definition; + return this; +} + +DefinitionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DefinitionContext.prototype.constructor = DefinitionContext; + +DefinitionContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +DefinitionContext.prototype.def_list = function() { + return this.getTypedRuleContext(Def_listContext,0); +}; + +DefinitionContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +DefinitionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDefinition(this); + } +}; + +DefinitionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDefinition(this); + } +}; + +DefinitionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDefinition(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DefinitionContext = DefinitionContext; + +PostgreSQLParser.prototype.definition = function() { + + var localctx = new DefinitionContext(this, this._ctx, this.state); + this.enterRule(localctx, 460, PostgreSQLParser.RULE_definition); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4210; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4211; + this.def_list(); + this.state = 4212; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Def_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_def_list; + return this; +} + +Def_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Def_listContext.prototype.constructor = Def_listContext; + +Def_listContext.prototype.def_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Def_elemContext); + } else { + return this.getTypedRuleContext(Def_elemContext,i); + } +}; + +Def_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Def_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDef_list(this); + } +}; + +Def_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDef_list(this); + } +}; + +Def_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDef_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Def_listContext = Def_listContext; + +PostgreSQLParser.prototype.def_list = function() { + + var localctx = new Def_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 462, PostgreSQLParser.RULE_def_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4214; + this.def_elem(); + this.state = 4219; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 4215; + this.match(PostgreSQLParser.COMMA); + this.state = 4216; + this.def_elem(); + this.state = 4221; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Def_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_def_elem; + return this; +} + +Def_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Def_elemContext.prototype.constructor = Def_elemContext; + +Def_elemContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +Def_elemContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +Def_elemContext.prototype.def_arg = function() { + return this.getTypedRuleContext(Def_argContext,0); +}; + +Def_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDef_elem(this); + } +}; + +Def_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDef_elem(this); + } +}; + +Def_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDef_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Def_elemContext = Def_elemContext; + +PostgreSQLParser.prototype.def_elem = function() { + + var localctx = new Def_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 464, PostgreSQLParser.RULE_def_elem); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4222; + this.collabel(); + this.state = 4225; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.EQUAL) { + this.state = 4223; + this.match(PostgreSQLParser.EQUAL); + this.state = 4224; + this.def_arg(); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Def_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_def_arg; + return this; +} + +Def_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Def_argContext.prototype.constructor = Def_argContext; + +Def_argContext.prototype.func_type = function() { + return this.getTypedRuleContext(Func_typeContext,0); +}; + +Def_argContext.prototype.reserved_keyword = function() { + return this.getTypedRuleContext(Reserved_keywordContext,0); +}; + +Def_argContext.prototype.qual_all_op = function() { + return this.getTypedRuleContext(Qual_all_opContext,0); +}; + +Def_argContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +Def_argContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Def_argContext.prototype.NONE = function() { + return this.getToken(PostgreSQLParser.NONE, 0); +}; + +Def_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDef_arg(this); + } +}; + +Def_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDef_arg(this); + } +}; + +Def_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDef_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Def_argContext = Def_argContext; + +PostgreSQLParser.prototype.def_arg = function() { + + var localctx = new Def_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 466, PostgreSQLParser.RULE_def_arg); + try { + this.state = 4233; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,201,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4227; + this.func_type(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4228; + this.reserved_keyword(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4229; + this.qual_all_op(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4230; + this.numericonly(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 4231; + this.sconst(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 4232; + this.match(PostgreSQLParser.NONE); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Old_aggr_definitionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_old_aggr_definition; + return this; +} + +Old_aggr_definitionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Old_aggr_definitionContext.prototype.constructor = Old_aggr_definitionContext; + +Old_aggr_definitionContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Old_aggr_definitionContext.prototype.old_aggr_list = function() { + return this.getTypedRuleContext(Old_aggr_listContext,0); +}; + +Old_aggr_definitionContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Old_aggr_definitionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOld_aggr_definition(this); + } +}; + +Old_aggr_definitionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOld_aggr_definition(this); + } +}; + +Old_aggr_definitionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOld_aggr_definition(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Old_aggr_definitionContext = Old_aggr_definitionContext; + +PostgreSQLParser.prototype.old_aggr_definition = function() { + + var localctx = new Old_aggr_definitionContext(this, this._ctx, this.state); + this.enterRule(localctx, 468, PostgreSQLParser.RULE_old_aggr_definition); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4235; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4236; + this.old_aggr_list(); + this.state = 4237; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Old_aggr_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_old_aggr_list; + return this; +} + +Old_aggr_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Old_aggr_listContext.prototype.constructor = Old_aggr_listContext; + +Old_aggr_listContext.prototype.old_aggr_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Old_aggr_elemContext); + } else { + return this.getTypedRuleContext(Old_aggr_elemContext,i); + } +}; + +Old_aggr_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Old_aggr_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOld_aggr_list(this); + } +}; + +Old_aggr_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOld_aggr_list(this); + } +}; + +Old_aggr_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOld_aggr_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Old_aggr_listContext = Old_aggr_listContext; + +PostgreSQLParser.prototype.old_aggr_list = function() { + + var localctx = new Old_aggr_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 470, PostgreSQLParser.RULE_old_aggr_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4239; + this.old_aggr_elem(); + this.state = 4244; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 4240; + this.match(PostgreSQLParser.COMMA); + this.state = 4241; + this.old_aggr_elem(); + this.state = 4246; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Old_aggr_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_old_aggr_elem; + return this; +} + +Old_aggr_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Old_aggr_elemContext.prototype.constructor = Old_aggr_elemContext; + +Old_aggr_elemContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +Old_aggr_elemContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +Old_aggr_elemContext.prototype.def_arg = function() { + return this.getTypedRuleContext(Def_argContext,0); +}; + +Old_aggr_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOld_aggr_elem(this); + } +}; + +Old_aggr_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOld_aggr_elem(this); + } +}; + +Old_aggr_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOld_aggr_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Old_aggr_elemContext = Old_aggr_elemContext; + +PostgreSQLParser.prototype.old_aggr_elem = function() { + + var localctx = new Old_aggr_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 472, PostgreSQLParser.RULE_old_aggr_elem); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4247; + this.identifier(); + this.state = 4248; + this.match(PostgreSQLParser.EQUAL); + this.state = 4249; + this.def_arg(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_enum_val_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_enum_val_list; + return this; +} + +Opt_enum_val_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_enum_val_listContext.prototype.constructor = Opt_enum_val_listContext; + +Opt_enum_val_listContext.prototype.enum_val_list = function() { + return this.getTypedRuleContext(Enum_val_listContext,0); +}; + +Opt_enum_val_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_enum_val_list(this); + } +}; + +Opt_enum_val_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_enum_val_list(this); + } +}; + +Opt_enum_val_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_enum_val_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_enum_val_listContext = Opt_enum_val_listContext; + +PostgreSQLParser.prototype.opt_enum_val_list = function() { + + var localctx = new Opt_enum_val_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 474, PostgreSQLParser.RULE_opt_enum_val_list); + try { + this.state = 4253; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 4251; + this.enum_val_list(); + break; + case PostgreSQLParser.CLOSE_PAREN: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Enum_val_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_enum_val_list; + return this; +} + +Enum_val_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Enum_val_listContext.prototype.constructor = Enum_val_listContext; + +Enum_val_listContext.prototype.sconst = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(SconstContext); + } else { + return this.getTypedRuleContext(SconstContext,i); + } +}; + +Enum_val_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Enum_val_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterEnum_val_list(this); + } +}; + +Enum_val_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitEnum_val_list(this); + } +}; + +Enum_val_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitEnum_val_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Enum_val_listContext = Enum_val_listContext; + +PostgreSQLParser.prototype.enum_val_list = function() { + + var localctx = new Enum_val_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 476, PostgreSQLParser.RULE_enum_val_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4255; + this.sconst(); + this.state = 4260; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 4256; + this.match(PostgreSQLParser.COMMA); + this.state = 4257; + this.sconst(); + this.state = 4262; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterenumstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterenumstmt; + return this; +} + +AlterenumstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterenumstmtContext.prototype.constructor = AlterenumstmtContext; + +AlterenumstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterenumstmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +AlterenumstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AlterenumstmtContext.prototype.ADD_P = function() { + return this.getToken(PostgreSQLParser.ADD_P, 0); +}; + +AlterenumstmtContext.prototype.VALUE_P = function() { + return this.getToken(PostgreSQLParser.VALUE_P, 0); +}; + +AlterenumstmtContext.prototype.opt_if_not_exists = function() { + return this.getTypedRuleContext(Opt_if_not_existsContext,0); +}; + +AlterenumstmtContext.prototype.sconst = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(SconstContext); + } else { + return this.getTypedRuleContext(SconstContext,i); + } +}; + +AlterenumstmtContext.prototype.BEFORE = function() { + return this.getToken(PostgreSQLParser.BEFORE, 0); +}; + +AlterenumstmtContext.prototype.AFTER = function() { + return this.getToken(PostgreSQLParser.AFTER, 0); +}; + +AlterenumstmtContext.prototype.RENAME = function() { + return this.getToken(PostgreSQLParser.RENAME, 0); +}; + +AlterenumstmtContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +AlterenumstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterenumstmt(this); + } +}; + +AlterenumstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterenumstmt(this); + } +}; + +AlterenumstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterenumstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterenumstmtContext = AlterenumstmtContext; + +PostgreSQLParser.prototype.alterenumstmt = function() { + + var localctx = new AlterenumstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 478, PostgreSQLParser.RULE_alterenumstmt); + try { + this.state = 4300; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,205,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4263; + this.match(PostgreSQLParser.ALTER); + this.state = 4264; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4265; + this.any_name(); + this.state = 4266; + this.match(PostgreSQLParser.ADD_P); + this.state = 4267; + this.match(PostgreSQLParser.VALUE_P); + this.state = 4268; + this.opt_if_not_exists(); + this.state = 4269; + this.sconst(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4271; + this.match(PostgreSQLParser.ALTER); + this.state = 4272; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4273; + this.any_name(); + this.state = 4274; + this.match(PostgreSQLParser.ADD_P); + this.state = 4275; + this.match(PostgreSQLParser.VALUE_P); + this.state = 4276; + this.opt_if_not_exists(); + this.state = 4277; + this.sconst(); + this.state = 4278; + this.match(PostgreSQLParser.BEFORE); + this.state = 4279; + this.sconst(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4281; + this.match(PostgreSQLParser.ALTER); + this.state = 4282; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4283; + this.any_name(); + this.state = 4284; + this.match(PostgreSQLParser.ADD_P); + this.state = 4285; + this.match(PostgreSQLParser.VALUE_P); + this.state = 4286; + this.opt_if_not_exists(); + this.state = 4287; + this.sconst(); + this.state = 4288; + this.match(PostgreSQLParser.AFTER); + this.state = 4289; + this.sconst(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4291; + this.match(PostgreSQLParser.ALTER); + this.state = 4292; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4293; + this.any_name(); + this.state = 4294; + this.match(PostgreSQLParser.RENAME); + this.state = 4295; + this.match(PostgreSQLParser.VALUE_P); + this.state = 4296; + this.sconst(); + this.state = 4297; + this.match(PostgreSQLParser.TO); + this.state = 4298; + this.sconst(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_if_not_existsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_if_not_exists; + return this; +} + +Opt_if_not_existsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_if_not_existsContext.prototype.constructor = Opt_if_not_existsContext; + +Opt_if_not_existsContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +Opt_if_not_existsContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +Opt_if_not_existsContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +Opt_if_not_existsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_if_not_exists(this); + } +}; + +Opt_if_not_existsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_if_not_exists(this); + } +}; + +Opt_if_not_existsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_if_not_exists(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_if_not_existsContext = Opt_if_not_existsContext; + +PostgreSQLParser.prototype.opt_if_not_exists = function() { + + var localctx = new Opt_if_not_existsContext(this, this._ctx, this.state); + this.enterRule(localctx, 480, PostgreSQLParser.RULE_opt_if_not_exists); + try { + this.state = 4306; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.IF_P: + this.enterOuterAlt(localctx, 1); + this.state = 4302; + this.match(PostgreSQLParser.IF_P); + this.state = 4303; + this.match(PostgreSQLParser.NOT); + this.state = 4304; + this.match(PostgreSQLParser.EXISTS); + break; + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateopclassstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createopclassstmt; + return this; +} + +CreateopclassstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateopclassstmtContext.prototype.constructor = CreateopclassstmtContext; + +CreateopclassstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateopclassstmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +CreateopclassstmtContext.prototype.CLASS = function() { + return this.getToken(PostgreSQLParser.CLASS, 0); +}; + +CreateopclassstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +CreateopclassstmtContext.prototype.opt_default = function() { + return this.getTypedRuleContext(Opt_defaultContext,0); +}; + +CreateopclassstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +CreateopclassstmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +CreateopclassstmtContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +CreateopclassstmtContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +CreateopclassstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreateopclassstmtContext.prototype.opt_opfamily = function() { + return this.getTypedRuleContext(Opt_opfamilyContext,0); +}; + +CreateopclassstmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +CreateopclassstmtContext.prototype.opclass_item_list = function() { + return this.getTypedRuleContext(Opclass_item_listContext,0); +}; + +CreateopclassstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateopclassstmt(this); + } +}; + +CreateopclassstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateopclassstmt(this); + } +}; + +CreateopclassstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateopclassstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateopclassstmtContext = CreateopclassstmtContext; + +PostgreSQLParser.prototype.createopclassstmt = function() { + + var localctx = new CreateopclassstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 482, PostgreSQLParser.RULE_createopclassstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4308; + this.match(PostgreSQLParser.CREATE); + this.state = 4309; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4310; + this.match(PostgreSQLParser.CLASS); + this.state = 4311; + this.any_name(); + this.state = 4312; + this.opt_default(); + this.state = 4313; + this.match(PostgreSQLParser.FOR); + this.state = 4314; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4315; + this.typename(); + this.state = 4316; + this.match(PostgreSQLParser.USING); + this.state = 4317; + this.name(); + this.state = 4318; + this.opt_opfamily(); + this.state = 4319; + this.match(PostgreSQLParser.AS); + this.state = 4320; + this.opclass_item_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opclass_item_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opclass_item_list; + return this; +} + +Opclass_item_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opclass_item_listContext.prototype.constructor = Opclass_item_listContext; + +Opclass_item_listContext.prototype.opclass_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Opclass_itemContext); + } else { + return this.getTypedRuleContext(Opclass_itemContext,i); + } +}; + +Opclass_item_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Opclass_item_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpclass_item_list(this); + } +}; + +Opclass_item_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpclass_item_list(this); + } +}; + +Opclass_item_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpclass_item_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opclass_item_listContext = Opclass_item_listContext; + +PostgreSQLParser.prototype.opclass_item_list = function() { + + var localctx = new Opclass_item_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 484, PostgreSQLParser.RULE_opclass_item_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4322; + this.opclass_item(); + this.state = 4327; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 4323; + this.match(PostgreSQLParser.COMMA); + this.state = 4324; + this.opclass_item(); + this.state = 4329; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opclass_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opclass_item; + return this; +} + +Opclass_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opclass_itemContext.prototype.constructor = Opclass_itemContext; + +Opclass_itemContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +Opclass_itemContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +Opclass_itemContext.prototype.any_operator = function() { + return this.getTypedRuleContext(Any_operatorContext,0); +}; + +Opclass_itemContext.prototype.opclass_purpose = function() { + return this.getTypedRuleContext(Opclass_purposeContext,0); +}; + +Opclass_itemContext.prototype.opt_recheck = function() { + return this.getTypedRuleContext(Opt_recheckContext,0); +}; + +Opclass_itemContext.prototype.operator_with_argtypes = function() { + return this.getTypedRuleContext(Operator_with_argtypesContext,0); +}; + +Opclass_itemContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +Opclass_itemContext.prototype.function_with_argtypes = function() { + return this.getTypedRuleContext(Function_with_argtypesContext,0); +}; + +Opclass_itemContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opclass_itemContext.prototype.type_list = function() { + return this.getTypedRuleContext(Type_listContext,0); +}; + +Opclass_itemContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opclass_itemContext.prototype.STORAGE = function() { + return this.getToken(PostgreSQLParser.STORAGE, 0); +}; + +Opclass_itemContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +Opclass_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpclass_item(this); + } +}; + +Opclass_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpclass_item(this); + } +}; + +Opclass_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpclass_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opclass_itemContext = Opclass_itemContext; + +PostgreSQLParser.prototype.opclass_item = function() { + + var localctx = new Opclass_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 486, PostgreSQLParser.RULE_opclass_item); + try { + this.state = 4355; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,208,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4330; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4331; + this.iconst(); + this.state = 4332; + this.any_operator(); + this.state = 4333; + this.opclass_purpose(); + this.state = 4334; + this.opt_recheck(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4336; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4337; + this.iconst(); + this.state = 4338; + this.operator_with_argtypes(); + this.state = 4339; + this.opclass_purpose(); + this.state = 4340; + this.opt_recheck(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4342; + this.match(PostgreSQLParser.FUNCTION); + this.state = 4343; + this.iconst(); + this.state = 4344; + this.function_with_argtypes(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4346; + this.match(PostgreSQLParser.FUNCTION); + this.state = 4347; + this.iconst(); + this.state = 4348; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4349; + this.type_list(); + this.state = 4350; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 4351; + this.function_with_argtypes(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 4353; + this.match(PostgreSQLParser.STORAGE); + this.state = 4354; + this.typename(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_defaultContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_default; + return this; +} + +Opt_defaultContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_defaultContext.prototype.constructor = Opt_defaultContext; + +Opt_defaultContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Opt_defaultContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_default(this); + } +}; + +Opt_defaultContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_default(this); + } +}; + +Opt_defaultContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_default(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_defaultContext = Opt_defaultContext; + +PostgreSQLParser.prototype.opt_default = function() { + + var localctx = new Opt_defaultContext(this, this._ctx, this.state); + this.enterRule(localctx, 488, PostgreSQLParser.RULE_opt_default); + try { + this.state = 4359; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.DEFAULT: + this.enterOuterAlt(localctx, 1); + this.state = 4357; + this.match(PostgreSQLParser.DEFAULT); + break; + case PostgreSQLParser.FOR: + case PostgreSQLParser.CONVERSION_P: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_opfamilyContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_opfamily; + return this; +} + +Opt_opfamilyContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_opfamilyContext.prototype.constructor = Opt_opfamilyContext; + +Opt_opfamilyContext.prototype.FAMILY = function() { + return this.getToken(PostgreSQLParser.FAMILY, 0); +}; + +Opt_opfamilyContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Opt_opfamilyContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_opfamily(this); + } +}; + +Opt_opfamilyContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_opfamily(this); + } +}; + +Opt_opfamilyContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_opfamily(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_opfamilyContext = Opt_opfamilyContext; + +PostgreSQLParser.prototype.opt_opfamily = function() { + + var localctx = new Opt_opfamilyContext(this, this._ctx, this.state); + this.enterRule(localctx, 490, PostgreSQLParser.RULE_opt_opfamily); + try { + this.state = 4364; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FAMILY: + this.enterOuterAlt(localctx, 1); + this.state = 4361; + this.match(PostgreSQLParser.FAMILY); + this.state = 4362; + this.any_name(); + break; + case PostgreSQLParser.AS: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opclass_purposeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opclass_purpose; + return this; +} + +Opclass_purposeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opclass_purposeContext.prototype.constructor = Opclass_purposeContext; + +Opclass_purposeContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Opclass_purposeContext.prototype.SEARCH = function() { + return this.getToken(PostgreSQLParser.SEARCH, 0); +}; + +Opclass_purposeContext.prototype.ORDER = function() { + return this.getToken(PostgreSQLParser.ORDER, 0); +}; + +Opclass_purposeContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Opclass_purposeContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Opclass_purposeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpclass_purpose(this); + } +}; + +Opclass_purposeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpclass_purpose(this); + } +}; + +Opclass_purposeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpclass_purpose(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opclass_purposeContext = Opclass_purposeContext; + +PostgreSQLParser.prototype.opclass_purpose = function() { + + var localctx = new Opclass_purposeContext(this, this._ctx, this.state); + this.enterRule(localctx, 492, PostgreSQLParser.RULE_opclass_purpose); + try { + this.state = 4373; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,211,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4366; + this.match(PostgreSQLParser.FOR); + this.state = 4367; + this.match(PostgreSQLParser.SEARCH); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4368; + this.match(PostgreSQLParser.FOR); + this.state = 4369; + this.match(PostgreSQLParser.ORDER); + this.state = 4370; + this.match(PostgreSQLParser.BY); + this.state = 4371; + this.any_name(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_recheckContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_recheck; + return this; +} + +Opt_recheckContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_recheckContext.prototype.constructor = Opt_recheckContext; + +Opt_recheckContext.prototype.RECHECK = function() { + return this.getToken(PostgreSQLParser.RECHECK, 0); +}; + +Opt_recheckContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_recheck(this); + } +}; + +Opt_recheckContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_recheck(this); + } +}; + +Opt_recheckContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_recheck(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_recheckContext = Opt_recheckContext; + +PostgreSQLParser.prototype.opt_recheck = function() { + + var localctx = new Opt_recheckContext(this, this._ctx, this.state); + this.enterRule(localctx, 494, PostgreSQLParser.RULE_opt_recheck); + try { + this.state = 4377; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.RECHECK: + this.enterOuterAlt(localctx, 1); + this.state = 4375; + this.match(PostgreSQLParser.RECHECK); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateopfamilystmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createopfamilystmt; + return this; +} + +CreateopfamilystmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateopfamilystmtContext.prototype.constructor = CreateopfamilystmtContext; + +CreateopfamilystmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateopfamilystmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +CreateopfamilystmtContext.prototype.FAMILY = function() { + return this.getToken(PostgreSQLParser.FAMILY, 0); +}; + +CreateopfamilystmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +CreateopfamilystmtContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +CreateopfamilystmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreateopfamilystmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateopfamilystmt(this); + } +}; + +CreateopfamilystmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateopfamilystmt(this); + } +}; + +CreateopfamilystmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateopfamilystmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateopfamilystmtContext = CreateopfamilystmtContext; + +PostgreSQLParser.prototype.createopfamilystmt = function() { + + var localctx = new CreateopfamilystmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 496, PostgreSQLParser.RULE_createopfamilystmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4379; + this.match(PostgreSQLParser.CREATE); + this.state = 4380; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4381; + this.match(PostgreSQLParser.FAMILY); + this.state = 4382; + this.any_name(); + this.state = 4383; + this.match(PostgreSQLParser.USING); + this.state = 4384; + this.name(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlteropfamilystmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alteropfamilystmt; + return this; +} + +AlteropfamilystmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlteropfamilystmtContext.prototype.constructor = AlteropfamilystmtContext; + +AlteropfamilystmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlteropfamilystmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +AlteropfamilystmtContext.prototype.FAMILY = function() { + return this.getToken(PostgreSQLParser.FAMILY, 0); +}; + +AlteropfamilystmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AlteropfamilystmtContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +AlteropfamilystmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AlteropfamilystmtContext.prototype.ADD_P = function() { + return this.getToken(PostgreSQLParser.ADD_P, 0); +}; + +AlteropfamilystmtContext.prototype.opclass_item_list = function() { + return this.getTypedRuleContext(Opclass_item_listContext,0); +}; + +AlteropfamilystmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +AlteropfamilystmtContext.prototype.opclass_drop_list = function() { + return this.getTypedRuleContext(Opclass_drop_listContext,0); +}; + +AlteropfamilystmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlteropfamilystmt(this); + } +}; + +AlteropfamilystmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlteropfamilystmt(this); + } +}; + +AlteropfamilystmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlteropfamilystmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlteropfamilystmtContext = AlteropfamilystmtContext; + +PostgreSQLParser.prototype.alteropfamilystmt = function() { + + var localctx = new AlteropfamilystmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 498, PostgreSQLParser.RULE_alteropfamilystmt); + try { + this.state = 4404; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,213,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4386; + this.match(PostgreSQLParser.ALTER); + this.state = 4387; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4388; + this.match(PostgreSQLParser.FAMILY); + this.state = 4389; + this.any_name(); + this.state = 4390; + this.match(PostgreSQLParser.USING); + this.state = 4391; + this.name(); + this.state = 4392; + this.match(PostgreSQLParser.ADD_P); + this.state = 4393; + this.opclass_item_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4395; + this.match(PostgreSQLParser.ALTER); + this.state = 4396; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4397; + this.match(PostgreSQLParser.FAMILY); + this.state = 4398; + this.any_name(); + this.state = 4399; + this.match(PostgreSQLParser.USING); + this.state = 4400; + this.name(); + this.state = 4401; + this.match(PostgreSQLParser.DROP); + this.state = 4402; + this.opclass_drop_list(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opclass_drop_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opclass_drop_list; + return this; +} + +Opclass_drop_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opclass_drop_listContext.prototype.constructor = Opclass_drop_listContext; + +Opclass_drop_listContext.prototype.opclass_drop = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Opclass_dropContext); + } else { + return this.getTypedRuleContext(Opclass_dropContext,i); + } +}; + +Opclass_drop_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Opclass_drop_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpclass_drop_list(this); + } +}; + +Opclass_drop_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpclass_drop_list(this); + } +}; + +Opclass_drop_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpclass_drop_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opclass_drop_listContext = Opclass_drop_listContext; + +PostgreSQLParser.prototype.opclass_drop_list = function() { + + var localctx = new Opclass_drop_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 500, PostgreSQLParser.RULE_opclass_drop_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4406; + this.opclass_drop(); + this.state = 4411; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 4407; + this.match(PostgreSQLParser.COMMA); + this.state = 4408; + this.opclass_drop(); + this.state = 4413; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opclass_dropContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opclass_drop; + return this; +} + +Opclass_dropContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opclass_dropContext.prototype.constructor = Opclass_dropContext; + +Opclass_dropContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +Opclass_dropContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +Opclass_dropContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opclass_dropContext.prototype.type_list = function() { + return this.getTypedRuleContext(Type_listContext,0); +}; + +Opclass_dropContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opclass_dropContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +Opclass_dropContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpclass_drop(this); + } +}; + +Opclass_dropContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpclass_drop(this); + } +}; + +Opclass_dropContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpclass_drop(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opclass_dropContext = Opclass_dropContext; + +PostgreSQLParser.prototype.opclass_drop = function() { + + var localctx = new Opclass_dropContext(this, this._ctx, this.state); + this.enterRule(localctx, 502, PostgreSQLParser.RULE_opclass_drop); + try { + this.state = 4426; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPERATOR: + this.enterOuterAlt(localctx, 1); + this.state = 4414; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4415; + this.iconst(); + this.state = 4416; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4417; + this.type_list(); + this.state = 4418; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.FUNCTION: + this.enterOuterAlt(localctx, 2); + this.state = 4420; + this.match(PostgreSQLParser.FUNCTION); + this.state = 4421; + this.iconst(); + this.state = 4422; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4423; + this.type_list(); + this.state = 4424; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DropopclassstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dropopclassstmt; + return this; +} + +DropopclassstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DropopclassstmtContext.prototype.constructor = DropopclassstmtContext; + +DropopclassstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DropopclassstmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +DropopclassstmtContext.prototype.CLASS = function() { + return this.getToken(PostgreSQLParser.CLASS, 0); +}; + +DropopclassstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +DropopclassstmtContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +DropopclassstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +DropopclassstmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +DropopclassstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +DropopclassstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +DropopclassstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDropopclassstmt(this); + } +}; + +DropopclassstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDropopclassstmt(this); + } +}; + +DropopclassstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDropopclassstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DropopclassstmtContext = DropopclassstmtContext; + +PostgreSQLParser.prototype.dropopclassstmt = function() { + + var localctx = new DropopclassstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 504, PostgreSQLParser.RULE_dropopclassstmt); + try { + this.state = 4446; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,216,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4428; + this.match(PostgreSQLParser.DROP); + this.state = 4429; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4430; + this.match(PostgreSQLParser.CLASS); + this.state = 4431; + this.any_name(); + this.state = 4432; + this.match(PostgreSQLParser.USING); + this.state = 4433; + this.name(); + this.state = 4434; + this.opt_drop_behavior(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4436; + this.match(PostgreSQLParser.DROP); + this.state = 4437; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4438; + this.match(PostgreSQLParser.CLASS); + this.state = 4439; + this.match(PostgreSQLParser.IF_P); + this.state = 4440; + this.match(PostgreSQLParser.EXISTS); + this.state = 4441; + this.any_name(); + this.state = 4442; + this.match(PostgreSQLParser.USING); + this.state = 4443; + this.name(); + this.state = 4444; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DropopfamilystmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dropopfamilystmt; + return this; +} + +DropopfamilystmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DropopfamilystmtContext.prototype.constructor = DropopfamilystmtContext; + +DropopfamilystmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DropopfamilystmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +DropopfamilystmtContext.prototype.FAMILY = function() { + return this.getToken(PostgreSQLParser.FAMILY, 0); +}; + +DropopfamilystmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +DropopfamilystmtContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +DropopfamilystmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +DropopfamilystmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +DropopfamilystmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +DropopfamilystmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +DropopfamilystmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDropopfamilystmt(this); + } +}; + +DropopfamilystmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDropopfamilystmt(this); + } +}; + +DropopfamilystmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDropopfamilystmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DropopfamilystmtContext = DropopfamilystmtContext; + +PostgreSQLParser.prototype.dropopfamilystmt = function() { + + var localctx = new DropopfamilystmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 506, PostgreSQLParser.RULE_dropopfamilystmt); + try { + this.state = 4466; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,217,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4448; + this.match(PostgreSQLParser.DROP); + this.state = 4449; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4450; + this.match(PostgreSQLParser.FAMILY); + this.state = 4451; + this.any_name(); + this.state = 4452; + this.match(PostgreSQLParser.USING); + this.state = 4453; + this.name(); + this.state = 4454; + this.opt_drop_behavior(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4456; + this.match(PostgreSQLParser.DROP); + this.state = 4457; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4458; + this.match(PostgreSQLParser.FAMILY); + this.state = 4459; + this.match(PostgreSQLParser.IF_P); + this.state = 4460; + this.match(PostgreSQLParser.EXISTS); + this.state = 4461; + this.any_name(); + this.state = 4462; + this.match(PostgreSQLParser.USING); + this.state = 4463; + this.name(); + this.state = 4464; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DropownedstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dropownedstmt; + return this; +} + +DropownedstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DropownedstmtContext.prototype.constructor = DropownedstmtContext; + +DropownedstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DropownedstmtContext.prototype.OWNED = function() { + return this.getToken(PostgreSQLParser.OWNED, 0); +}; + +DropownedstmtContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +DropownedstmtContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +DropownedstmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +DropownedstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDropownedstmt(this); + } +}; + +DropownedstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDropownedstmt(this); + } +}; + +DropownedstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDropownedstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DropownedstmtContext = DropownedstmtContext; + +PostgreSQLParser.prototype.dropownedstmt = function() { + + var localctx = new DropownedstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 508, PostgreSQLParser.RULE_dropownedstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4468; + this.match(PostgreSQLParser.DROP); + this.state = 4469; + this.match(PostgreSQLParser.OWNED); + this.state = 4470; + this.match(PostgreSQLParser.BY); + this.state = 4471; + this.role_list(); + this.state = 4472; + this.opt_drop_behavior(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ReassignownedstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reassignownedstmt; + return this; +} + +ReassignownedstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ReassignownedstmtContext.prototype.constructor = ReassignownedstmtContext; + +ReassignownedstmtContext.prototype.REASSIGN = function() { + return this.getToken(PostgreSQLParser.REASSIGN, 0); +}; + +ReassignownedstmtContext.prototype.OWNED = function() { + return this.getToken(PostgreSQLParser.OWNED, 0); +}; + +ReassignownedstmtContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +ReassignownedstmtContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +ReassignownedstmtContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +ReassignownedstmtContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +ReassignownedstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReassignownedstmt(this); + } +}; + +ReassignownedstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReassignownedstmt(this); + } +}; + +ReassignownedstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReassignownedstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ReassignownedstmtContext = ReassignownedstmtContext; + +PostgreSQLParser.prototype.reassignownedstmt = function() { + + var localctx = new ReassignownedstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 510, PostgreSQLParser.RULE_reassignownedstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4474; + this.match(PostgreSQLParser.REASSIGN); + this.state = 4475; + this.match(PostgreSQLParser.OWNED); + this.state = 4476; + this.match(PostgreSQLParser.BY); + this.state = 4477; + this.role_list(); + this.state = 4478; + this.match(PostgreSQLParser.TO); + this.state = 4479; + this.rolespec(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DropstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dropstmt; + return this; +} + +DropstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DropstmtContext.prototype.constructor = DropstmtContext; + +DropstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DropstmtContext.prototype.object_type_any_name = function() { + return this.getTypedRuleContext(Object_type_any_nameContext,0); +}; + +DropstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +DropstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +DropstmtContext.prototype.any_name_list = function() { + return this.getTypedRuleContext(Any_name_listContext,0); +}; + +DropstmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +DropstmtContext.prototype.drop_type_name = function() { + return this.getTypedRuleContext(Drop_type_nameContext,0); +}; + +DropstmtContext.prototype.name_list = function() { + return this.getTypedRuleContext(Name_listContext,0); +}; + +DropstmtContext.prototype.object_type_name_on_any_name = function() { + return this.getTypedRuleContext(Object_type_name_on_any_nameContext,0); +}; + +DropstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +DropstmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +DropstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +DropstmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +DropstmtContext.prototype.type_name_list = function() { + return this.getTypedRuleContext(Type_name_listContext,0); +}; + +DropstmtContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +DropstmtContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +DropstmtContext.prototype.CONCURRENTLY = function() { + return this.getToken(PostgreSQLParser.CONCURRENTLY, 0); +}; + +DropstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDropstmt(this); + } +}; + +DropstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDropstmt(this); + } +}; + +DropstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDropstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DropstmtContext = DropstmtContext; + +PostgreSQLParser.prototype.dropstmt = function() { + + var localctx = new DropstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 512, PostgreSQLParser.RULE_dropstmt); + try { + this.state = 4559; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,218,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4481; + this.match(PostgreSQLParser.DROP); + this.state = 4482; + this.object_type_any_name(); + this.state = 4483; + this.match(PostgreSQLParser.IF_P); + this.state = 4484; + this.match(PostgreSQLParser.EXISTS); + this.state = 4485; + this.any_name_list(); + this.state = 4486; + this.opt_drop_behavior(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4488; + this.match(PostgreSQLParser.DROP); + this.state = 4489; + this.object_type_any_name(); + this.state = 4490; + this.any_name_list(); + this.state = 4491; + this.opt_drop_behavior(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4493; + this.match(PostgreSQLParser.DROP); + this.state = 4494; + this.drop_type_name(); + this.state = 4495; + this.match(PostgreSQLParser.IF_P); + this.state = 4496; + this.match(PostgreSQLParser.EXISTS); + this.state = 4497; + this.name_list(); + this.state = 4498; + this.opt_drop_behavior(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4500; + this.match(PostgreSQLParser.DROP); + this.state = 4501; + this.drop_type_name(); + this.state = 4502; + this.name_list(); + this.state = 4503; + this.opt_drop_behavior(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 4505; + this.match(PostgreSQLParser.DROP); + this.state = 4506; + this.object_type_name_on_any_name(); + this.state = 4507; + this.name(); + this.state = 4508; + this.match(PostgreSQLParser.ON); + this.state = 4509; + this.any_name(); + this.state = 4510; + this.opt_drop_behavior(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 4512; + this.match(PostgreSQLParser.DROP); + this.state = 4513; + this.object_type_name_on_any_name(); + this.state = 4514; + this.match(PostgreSQLParser.IF_P); + this.state = 4515; + this.match(PostgreSQLParser.EXISTS); + this.state = 4516; + this.name(); + this.state = 4517; + this.match(PostgreSQLParser.ON); + this.state = 4518; + this.any_name(); + this.state = 4519; + this.opt_drop_behavior(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 4521; + this.match(PostgreSQLParser.DROP); + this.state = 4522; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4523; + this.type_name_list(); + this.state = 4524; + this.opt_drop_behavior(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 4526; + this.match(PostgreSQLParser.DROP); + this.state = 4527; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4528; + this.match(PostgreSQLParser.IF_P); + this.state = 4529; + this.match(PostgreSQLParser.EXISTS); + this.state = 4530; + this.type_name_list(); + this.state = 4531; + this.opt_drop_behavior(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 4533; + this.match(PostgreSQLParser.DROP); + this.state = 4534; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 4535; + this.type_name_list(); + this.state = 4536; + this.opt_drop_behavior(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 4538; + this.match(PostgreSQLParser.DROP); + this.state = 4539; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 4540; + this.match(PostgreSQLParser.IF_P); + this.state = 4541; + this.match(PostgreSQLParser.EXISTS); + this.state = 4542; + this.type_name_list(); + this.state = 4543; + this.opt_drop_behavior(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 4545; + this.match(PostgreSQLParser.DROP); + this.state = 4546; + this.match(PostgreSQLParser.INDEX); + this.state = 4547; + this.match(PostgreSQLParser.CONCURRENTLY); + this.state = 4548; + this.any_name_list(); + this.state = 4549; + this.opt_drop_behavior(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 4551; + this.match(PostgreSQLParser.DROP); + this.state = 4552; + this.match(PostgreSQLParser.INDEX); + this.state = 4553; + this.match(PostgreSQLParser.CONCURRENTLY); + this.state = 4554; + this.match(PostgreSQLParser.IF_P); + this.state = 4555; + this.match(PostgreSQLParser.EXISTS); + this.state = 4556; + this.any_name_list(); + this.state = 4557; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Object_type_any_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_object_type_any_name; + return this; +} + +Object_type_any_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Object_type_any_nameContext.prototype.constructor = Object_type_any_nameContext; + +Object_type_any_nameContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +Object_type_any_nameContext.prototype.SEQUENCE = function() { + return this.getToken(PostgreSQLParser.SEQUENCE, 0); +}; + +Object_type_any_nameContext.prototype.VIEW = function() { + return this.getToken(PostgreSQLParser.VIEW, 0); +}; + +Object_type_any_nameContext.prototype.MATERIALIZED = function() { + return this.getToken(PostgreSQLParser.MATERIALIZED, 0); +}; + +Object_type_any_nameContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +Object_type_any_nameContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +Object_type_any_nameContext.prototype.COLLATION = function() { + return this.getToken(PostgreSQLParser.COLLATION, 0); +}; + +Object_type_any_nameContext.prototype.CONVERSION_P = function() { + return this.getToken(PostgreSQLParser.CONVERSION_P, 0); +}; + +Object_type_any_nameContext.prototype.STATISTICS = function() { + return this.getToken(PostgreSQLParser.STATISTICS, 0); +}; + +Object_type_any_nameContext.prototype.TEXT_P = function() { + return this.getToken(PostgreSQLParser.TEXT_P, 0); +}; + +Object_type_any_nameContext.prototype.SEARCH = function() { + return this.getToken(PostgreSQLParser.SEARCH, 0); +}; + +Object_type_any_nameContext.prototype.PARSER = function() { + return this.getToken(PostgreSQLParser.PARSER, 0); +}; + +Object_type_any_nameContext.prototype.DICTIONARY = function() { + return this.getToken(PostgreSQLParser.DICTIONARY, 0); +}; + +Object_type_any_nameContext.prototype.TEMPLATE = function() { + return this.getToken(PostgreSQLParser.TEMPLATE, 0); +}; + +Object_type_any_nameContext.prototype.CONFIGURATION = function() { + return this.getToken(PostgreSQLParser.CONFIGURATION, 0); +}; + +Object_type_any_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterObject_type_any_name(this); + } +}; + +Object_type_any_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitObject_type_any_name(this); + } +}; + +Object_type_any_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitObject_type_any_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Object_type_any_nameContext = Object_type_any_nameContext; + +PostgreSQLParser.prototype.object_type_any_name = function() { + + var localctx = new Object_type_any_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 514, PostgreSQLParser.RULE_object_type_any_name); + try { + this.state = 4584; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,219,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4561; + this.match(PostgreSQLParser.TABLE); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4562; + this.match(PostgreSQLParser.SEQUENCE); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4563; + this.match(PostgreSQLParser.VIEW); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4564; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 4565; + this.match(PostgreSQLParser.VIEW); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 4566; + this.match(PostgreSQLParser.INDEX); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 4567; + this.match(PostgreSQLParser.FOREIGN); + this.state = 4568; + this.match(PostgreSQLParser.TABLE); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 4569; + this.match(PostgreSQLParser.COLLATION); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 4570; + this.match(PostgreSQLParser.CONVERSION_P); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 4571; + this.match(PostgreSQLParser.STATISTICS); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 4572; + this.match(PostgreSQLParser.TEXT_P); + this.state = 4573; + this.match(PostgreSQLParser.SEARCH); + this.state = 4574; + this.match(PostgreSQLParser.PARSER); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 4575; + this.match(PostgreSQLParser.TEXT_P); + this.state = 4576; + this.match(PostgreSQLParser.SEARCH); + this.state = 4577; + this.match(PostgreSQLParser.DICTIONARY); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 4578; + this.match(PostgreSQLParser.TEXT_P); + this.state = 4579; + this.match(PostgreSQLParser.SEARCH); + this.state = 4580; + this.match(PostgreSQLParser.TEMPLATE); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 4581; + this.match(PostgreSQLParser.TEXT_P); + this.state = 4582; + this.match(PostgreSQLParser.SEARCH); + this.state = 4583; + this.match(PostgreSQLParser.CONFIGURATION); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Object_type_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_object_type_name; + return this; +} + +Object_type_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Object_type_nameContext.prototype.constructor = Object_type_nameContext; + +Object_type_nameContext.prototype.drop_type_name = function() { + return this.getTypedRuleContext(Drop_type_nameContext,0); +}; + +Object_type_nameContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +Object_type_nameContext.prototype.ROLE = function() { + return this.getToken(PostgreSQLParser.ROLE, 0); +}; + +Object_type_nameContext.prototype.SUBSCRIPTION = function() { + return this.getToken(PostgreSQLParser.SUBSCRIPTION, 0); +}; + +Object_type_nameContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +Object_type_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterObject_type_name(this); + } +}; + +Object_type_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitObject_type_name(this); + } +}; + +Object_type_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitObject_type_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Object_type_nameContext = Object_type_nameContext; + +PostgreSQLParser.prototype.object_type_name = function() { + + var localctx = new Object_type_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 516, PostgreSQLParser.RULE_object_type_name); + try { + this.state = 4591; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FOREIGN: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.PUBLICATION: + this.enterOuterAlt(localctx, 1); + this.state = 4586; + this.drop_type_name(); + break; + case PostgreSQLParser.DATABASE: + this.enterOuterAlt(localctx, 2); + this.state = 4587; + this.match(PostgreSQLParser.DATABASE); + break; + case PostgreSQLParser.ROLE: + this.enterOuterAlt(localctx, 3); + this.state = 4588; + this.match(PostgreSQLParser.ROLE); + break; + case PostgreSQLParser.SUBSCRIPTION: + this.enterOuterAlt(localctx, 4); + this.state = 4589; + this.match(PostgreSQLParser.SUBSCRIPTION); + break; + case PostgreSQLParser.TABLESPACE: + this.enterOuterAlt(localctx, 5); + this.state = 4590; + this.match(PostgreSQLParser.TABLESPACE); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Drop_type_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_drop_type_name; + return this; +} + +Drop_type_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Drop_type_nameContext.prototype.constructor = Drop_type_nameContext; + +Drop_type_nameContext.prototype.ACCESS = function() { + return this.getToken(PostgreSQLParser.ACCESS, 0); +}; + +Drop_type_nameContext.prototype.METHOD = function() { + return this.getToken(PostgreSQLParser.METHOD, 0); +}; + +Drop_type_nameContext.prototype.EVENT = function() { + return this.getToken(PostgreSQLParser.EVENT, 0); +}; + +Drop_type_nameContext.prototype.TRIGGER = function() { + return this.getToken(PostgreSQLParser.TRIGGER, 0); +}; + +Drop_type_nameContext.prototype.EXTENSION = function() { + return this.getToken(PostgreSQLParser.EXTENSION, 0); +}; + +Drop_type_nameContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +Drop_type_nameContext.prototype.DATA_P = function() { + return this.getToken(PostgreSQLParser.DATA_P, 0); +}; + +Drop_type_nameContext.prototype.WRAPPER = function() { + return this.getToken(PostgreSQLParser.WRAPPER, 0); +}; + +Drop_type_nameContext.prototype.opt_procedural = function() { + return this.getTypedRuleContext(Opt_proceduralContext,0); +}; + +Drop_type_nameContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +Drop_type_nameContext.prototype.PUBLICATION = function() { + return this.getToken(PostgreSQLParser.PUBLICATION, 0); +}; + +Drop_type_nameContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +Drop_type_nameContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +Drop_type_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDrop_type_name(this); + } +}; + +Drop_type_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDrop_type_name(this); + } +}; + +Drop_type_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDrop_type_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Drop_type_nameContext = Drop_type_nameContext; + +PostgreSQLParser.prototype.drop_type_name = function() { + + var localctx = new Drop_type_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 518, PostgreSQLParser.RULE_drop_type_name); + try { + this.state = 4607; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ACCESS: + this.enterOuterAlt(localctx, 1); + this.state = 4593; + this.match(PostgreSQLParser.ACCESS); + this.state = 4594; + this.match(PostgreSQLParser.METHOD); + break; + case PostgreSQLParser.EVENT: + this.enterOuterAlt(localctx, 2); + this.state = 4595; + this.match(PostgreSQLParser.EVENT); + this.state = 4596; + this.match(PostgreSQLParser.TRIGGER); + break; + case PostgreSQLParser.EXTENSION: + this.enterOuterAlt(localctx, 3); + this.state = 4597; + this.match(PostgreSQLParser.EXTENSION); + break; + case PostgreSQLParser.FOREIGN: + this.enterOuterAlt(localctx, 4); + this.state = 4598; + this.match(PostgreSQLParser.FOREIGN); + this.state = 4599; + this.match(PostgreSQLParser.DATA_P); + this.state = 4600; + this.match(PostgreSQLParser.WRAPPER); + break; + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.PROCEDURAL: + this.enterOuterAlt(localctx, 5); + this.state = 4601; + this.opt_procedural(); + this.state = 4602; + this.match(PostgreSQLParser.LANGUAGE); + break; + case PostgreSQLParser.PUBLICATION: + this.enterOuterAlt(localctx, 6); + this.state = 4604; + this.match(PostgreSQLParser.PUBLICATION); + break; + case PostgreSQLParser.SCHEMA: + this.enterOuterAlt(localctx, 7); + this.state = 4605; + this.match(PostgreSQLParser.SCHEMA); + break; + case PostgreSQLParser.SERVER: + this.enterOuterAlt(localctx, 8); + this.state = 4606; + this.match(PostgreSQLParser.SERVER); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Object_type_name_on_any_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_object_type_name_on_any_name; + return this; +} + +Object_type_name_on_any_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Object_type_name_on_any_nameContext.prototype.constructor = Object_type_name_on_any_nameContext; + +Object_type_name_on_any_nameContext.prototype.POLICY = function() { + return this.getToken(PostgreSQLParser.POLICY, 0); +}; + +Object_type_name_on_any_nameContext.prototype.RULE = function() { + return this.getToken(PostgreSQLParser.RULE, 0); +}; + +Object_type_name_on_any_nameContext.prototype.TRIGGER = function() { + return this.getToken(PostgreSQLParser.TRIGGER, 0); +}; + +Object_type_name_on_any_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterObject_type_name_on_any_name(this); + } +}; + +Object_type_name_on_any_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitObject_type_name_on_any_name(this); + } +}; + +Object_type_name_on_any_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitObject_type_name_on_any_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Object_type_name_on_any_nameContext = Object_type_name_on_any_nameContext; + +PostgreSQLParser.prototype.object_type_name_on_any_name = function() { + + var localctx = new Object_type_name_on_any_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 520, PostgreSQLParser.RULE_object_type_name_on_any_name); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4609; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.RULE || _la===PostgreSQLParser.TRIGGER || _la===PostgreSQLParser.POLICY)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Any_name_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_any_name_list; + return this; +} + +Any_name_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Any_name_listContext.prototype.constructor = Any_name_listContext; + +Any_name_listContext.prototype.any_name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Any_nameContext); + } else { + return this.getTypedRuleContext(Any_nameContext,i); + } +}; + +Any_name_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Any_name_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAny_name_list(this); + } +}; + +Any_name_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAny_name_list(this); + } +}; + +Any_name_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAny_name_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Any_name_listContext = Any_name_listContext; + +PostgreSQLParser.prototype.any_name_list = function() { + + var localctx = new Any_name_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 522, PostgreSQLParser.RULE_any_name_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4611; + this.any_name(); + this.state = 4616; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 4612; + this.match(PostgreSQLParser.COMMA); + this.state = 4613; + this.any_name(); + this.state = 4618; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Any_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_any_name; + return this; +} + +Any_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Any_nameContext.prototype.constructor = Any_nameContext; + +Any_nameContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Any_nameContext.prototype.attrs = function() { + return this.getTypedRuleContext(AttrsContext,0); +}; + +Any_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAny_name(this); + } +}; + +Any_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAny_name(this); + } +}; + +Any_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAny_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Any_nameContext = Any_nameContext; + +PostgreSQLParser.prototype.any_name = function() { + + var localctx = new Any_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 524, PostgreSQLParser.RULE_any_name); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4619; + this.colid(); + this.state = 4621; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.DOT) { + this.state = 4620; + this.attrs(); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AttrsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_attrs; + return this; +} + +AttrsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AttrsContext.prototype.constructor = AttrsContext; + +AttrsContext.prototype.DOT = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.DOT); + } else { + return this.getToken(PostgreSQLParser.DOT, i); + } +}; + + +AttrsContext.prototype.attr_name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Attr_nameContext); + } else { + return this.getTypedRuleContext(Attr_nameContext,i); + } +}; + +AttrsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAttrs(this); + } +}; + +AttrsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAttrs(this); + } +}; + +AttrsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAttrs(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AttrsContext = AttrsContext; + +PostgreSQLParser.prototype.attrs = function() { + + var localctx = new AttrsContext(this, this._ctx, this.state); + this.enterRule(localctx, 526, PostgreSQLParser.RULE_attrs); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4625; + this._errHandler.sync(this); + var _alt = 1; + do { + switch (_alt) { + case 1: + this.state = 4623; + this.match(PostgreSQLParser.DOT); + this.state = 4624; + this.attr_name(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 4627; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,224, this._ctx); + } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER ); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Type_name_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_type_name_list; + return this; +} + +Type_name_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Type_name_listContext.prototype.constructor = Type_name_listContext; + +Type_name_listContext.prototype.typename = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TypenameContext); + } else { + return this.getTypedRuleContext(TypenameContext,i); + } +}; + +Type_name_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Type_name_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterType_name_list(this); + } +}; + +Type_name_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitType_name_list(this); + } +}; + +Type_name_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitType_name_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Type_name_listContext = Type_name_listContext; + +PostgreSQLParser.prototype.type_name_list = function() { + + var localctx = new Type_name_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 528, PostgreSQLParser.RULE_type_name_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4629; + this.typename(); + this.state = 4634; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 4630; + this.match(PostgreSQLParser.COMMA); + this.state = 4631; + this.typename(); + this.state = 4636; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TruncatestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_truncatestmt; + return this; +} + +TruncatestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TruncatestmtContext.prototype.constructor = TruncatestmtContext; + +TruncatestmtContext.prototype.TRUNCATE = function() { + return this.getToken(PostgreSQLParser.TRUNCATE, 0); +}; + +TruncatestmtContext.prototype.opt_table = function() { + return this.getTypedRuleContext(Opt_tableContext,0); +}; + +TruncatestmtContext.prototype.relation_expr_list = function() { + return this.getTypedRuleContext(Relation_expr_listContext,0); +}; + +TruncatestmtContext.prototype.opt_restart_seqs = function() { + return this.getTypedRuleContext(Opt_restart_seqsContext,0); +}; + +TruncatestmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +TruncatestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTruncatestmt(this); + } +}; + +TruncatestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTruncatestmt(this); + } +}; + +TruncatestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTruncatestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TruncatestmtContext = TruncatestmtContext; + +PostgreSQLParser.prototype.truncatestmt = function() { + + var localctx = new TruncatestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 530, PostgreSQLParser.RULE_truncatestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4637; + this.match(PostgreSQLParser.TRUNCATE); + this.state = 4638; + this.opt_table(); + this.state = 4639; + this.relation_expr_list(); + this.state = 4640; + this.opt_restart_seqs(); + this.state = 4641; + this.opt_drop_behavior(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_restart_seqsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_restart_seqs; + return this; +} + +Opt_restart_seqsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_restart_seqsContext.prototype.constructor = Opt_restart_seqsContext; + +Opt_restart_seqsContext.prototype.CONTINUE_P = function() { + return this.getToken(PostgreSQLParser.CONTINUE_P, 0); +}; + +Opt_restart_seqsContext.prototype.IDENTITY_P = function() { + return this.getToken(PostgreSQLParser.IDENTITY_P, 0); +}; + +Opt_restart_seqsContext.prototype.RESTART = function() { + return this.getToken(PostgreSQLParser.RESTART, 0); +}; + +Opt_restart_seqsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_restart_seqs(this); + } +}; + +Opt_restart_seqsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_restart_seqs(this); + } +}; + +Opt_restart_seqsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_restart_seqs(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_restart_seqsContext = Opt_restart_seqsContext; + +PostgreSQLParser.prototype.opt_restart_seqs = function() { + + var localctx = new Opt_restart_seqsContext(this, this._ctx, this.state); + this.enterRule(localctx, 532, PostgreSQLParser.RULE_opt_restart_seqs); + try { + this.state = 4648; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CONTINUE_P: + this.enterOuterAlt(localctx, 1); + this.state = 4643; + this.match(PostgreSQLParser.CONTINUE_P); + this.state = 4644; + this.match(PostgreSQLParser.IDENTITY_P); + break; + case PostgreSQLParser.RESTART: + this.enterOuterAlt(localctx, 2); + this.state = 4645; + this.match(PostgreSQLParser.RESTART); + this.state = 4646; + this.match(PostgreSQLParser.IDENTITY_P); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CommentstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_commentstmt; + return this; +} + +CommentstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CommentstmtContext.prototype.constructor = CommentstmtContext; + +CommentstmtContext.prototype.COMMENT = function() { + return this.getToken(PostgreSQLParser.COMMENT, 0); +}; + +CommentstmtContext.prototype.ON = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.ON); + } else { + return this.getToken(PostgreSQLParser.ON, i); + } +}; + + +CommentstmtContext.prototype.object_type_any_name = function() { + return this.getTypedRuleContext(Object_type_any_nameContext,0); +}; + +CommentstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +CommentstmtContext.prototype.IS = function() { + return this.getToken(PostgreSQLParser.IS, 0); +}; + +CommentstmtContext.prototype.comment_text = function() { + return this.getTypedRuleContext(Comment_textContext,0); +}; + +CommentstmtContext.prototype.COLUMN = function() { + return this.getToken(PostgreSQLParser.COLUMN, 0); +}; + +CommentstmtContext.prototype.object_type_name = function() { + return this.getTypedRuleContext(Object_type_nameContext,0); +}; + +CommentstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CommentstmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +CommentstmtContext.prototype.typename = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TypenameContext); + } else { + return this.getTypedRuleContext(TypenameContext,i); + } +}; + +CommentstmtContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +CommentstmtContext.prototype.AGGREGATE = function() { + return this.getToken(PostgreSQLParser.AGGREGATE, 0); +}; + +CommentstmtContext.prototype.aggregate_with_argtypes = function() { + return this.getTypedRuleContext(Aggregate_with_argtypesContext,0); +}; + +CommentstmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +CommentstmtContext.prototype.function_with_argtypes = function() { + return this.getTypedRuleContext(Function_with_argtypesContext,0); +}; + +CommentstmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +CommentstmtContext.prototype.operator_with_argtypes = function() { + return this.getTypedRuleContext(Operator_with_argtypesContext,0); +}; + +CommentstmtContext.prototype.CONSTRAINT = function() { + return this.getToken(PostgreSQLParser.CONSTRAINT, 0); +}; + +CommentstmtContext.prototype.object_type_name_on_any_name = function() { + return this.getTypedRuleContext(Object_type_name_on_any_nameContext,0); +}; + +CommentstmtContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +CommentstmtContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +CommentstmtContext.prototype.TRANSFORM = function() { + return this.getToken(PostgreSQLParser.TRANSFORM, 0); +}; + +CommentstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +CommentstmtContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +CommentstmtContext.prototype.CLASS = function() { + return this.getToken(PostgreSQLParser.CLASS, 0); +}; + +CommentstmtContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +CommentstmtContext.prototype.FAMILY = function() { + return this.getToken(PostgreSQLParser.FAMILY, 0); +}; + +CommentstmtContext.prototype.LARGE_P = function() { + return this.getToken(PostgreSQLParser.LARGE_P, 0); +}; + +CommentstmtContext.prototype.OBJECT_P = function() { + return this.getToken(PostgreSQLParser.OBJECT_P, 0); +}; + +CommentstmtContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +CommentstmtContext.prototype.CAST = function() { + return this.getToken(PostgreSQLParser.CAST, 0); +}; + +CommentstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CommentstmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +CommentstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CommentstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCommentstmt(this); + } +}; + +CommentstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCommentstmt(this); + } +}; + +CommentstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCommentstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CommentstmtContext = CommentstmtContext; + +PostgreSQLParser.prototype.commentstmt = function() { + + var localctx = new CommentstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 534, PostgreSQLParser.RULE_commentstmt); + try { + this.state = 4797; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,227,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4650; + this.match(PostgreSQLParser.COMMENT); + this.state = 4651; + this.match(PostgreSQLParser.ON); + this.state = 4652; + this.object_type_any_name(); + this.state = 4653; + this.any_name(); + this.state = 4654; + this.match(PostgreSQLParser.IS); + this.state = 4655; + this.comment_text(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4657; + this.match(PostgreSQLParser.COMMENT); + this.state = 4658; + this.match(PostgreSQLParser.ON); + this.state = 4659; + this.match(PostgreSQLParser.COLUMN); + this.state = 4660; + this.any_name(); + this.state = 4661; + this.match(PostgreSQLParser.IS); + this.state = 4662; + this.comment_text(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4664; + this.match(PostgreSQLParser.COMMENT); + this.state = 4665; + this.match(PostgreSQLParser.ON); + this.state = 4666; + this.object_type_name(); + this.state = 4667; + this.name(); + this.state = 4668; + this.match(PostgreSQLParser.IS); + this.state = 4669; + this.comment_text(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4671; + this.match(PostgreSQLParser.COMMENT); + this.state = 4672; + this.match(PostgreSQLParser.ON); + this.state = 4673; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4674; + this.typename(); + this.state = 4675; + this.match(PostgreSQLParser.IS); + this.state = 4676; + this.comment_text(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 4678; + this.match(PostgreSQLParser.COMMENT); + this.state = 4679; + this.match(PostgreSQLParser.ON); + this.state = 4680; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 4681; + this.typename(); + this.state = 4682; + this.match(PostgreSQLParser.IS); + this.state = 4683; + this.comment_text(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 4685; + this.match(PostgreSQLParser.COMMENT); + this.state = 4686; + this.match(PostgreSQLParser.ON); + this.state = 4687; + this.match(PostgreSQLParser.AGGREGATE); + this.state = 4688; + this.aggregate_with_argtypes(); + this.state = 4689; + this.match(PostgreSQLParser.IS); + this.state = 4690; + this.comment_text(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 4692; + this.match(PostgreSQLParser.COMMENT); + this.state = 4693; + this.match(PostgreSQLParser.ON); + this.state = 4694; + this.match(PostgreSQLParser.FUNCTION); + this.state = 4695; + this.function_with_argtypes(); + this.state = 4696; + this.match(PostgreSQLParser.IS); + this.state = 4697; + this.comment_text(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 4699; + this.match(PostgreSQLParser.COMMENT); + this.state = 4700; + this.match(PostgreSQLParser.ON); + this.state = 4701; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4702; + this.operator_with_argtypes(); + this.state = 4703; + this.match(PostgreSQLParser.IS); + this.state = 4704; + this.comment_text(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 4706; + this.match(PostgreSQLParser.COMMENT); + this.state = 4707; + this.match(PostgreSQLParser.ON); + this.state = 4708; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 4709; + this.name(); + this.state = 4710; + this.match(PostgreSQLParser.ON); + this.state = 4711; + this.any_name(); + this.state = 4712; + this.match(PostgreSQLParser.IS); + this.state = 4713; + this.comment_text(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 4715; + this.match(PostgreSQLParser.COMMENT); + this.state = 4716; + this.match(PostgreSQLParser.ON); + this.state = 4717; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 4718; + this.name(); + this.state = 4719; + this.match(PostgreSQLParser.ON); + this.state = 4720; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 4721; + this.any_name(); + this.state = 4722; + this.match(PostgreSQLParser.IS); + this.state = 4723; + this.comment_text(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 4725; + this.match(PostgreSQLParser.COMMENT); + this.state = 4726; + this.match(PostgreSQLParser.ON); + this.state = 4727; + this.object_type_name_on_any_name(); + this.state = 4728; + this.name(); + this.state = 4729; + this.match(PostgreSQLParser.ON); + this.state = 4730; + this.any_name(); + this.state = 4731; + this.match(PostgreSQLParser.IS); + this.state = 4732; + this.comment_text(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 4734; + this.match(PostgreSQLParser.COMMENT); + this.state = 4735; + this.match(PostgreSQLParser.ON); + this.state = 4736; + this.match(PostgreSQLParser.PROCEDURE); + this.state = 4737; + this.function_with_argtypes(); + this.state = 4738; + this.match(PostgreSQLParser.IS); + this.state = 4739; + this.comment_text(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 4741; + this.match(PostgreSQLParser.COMMENT); + this.state = 4742; + this.match(PostgreSQLParser.ON); + this.state = 4743; + this.match(PostgreSQLParser.ROUTINE); + this.state = 4744; + this.function_with_argtypes(); + this.state = 4745; + this.match(PostgreSQLParser.IS); + this.state = 4746; + this.comment_text(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 4748; + this.match(PostgreSQLParser.COMMENT); + this.state = 4749; + this.match(PostgreSQLParser.ON); + this.state = 4750; + this.match(PostgreSQLParser.TRANSFORM); + this.state = 4751; + this.match(PostgreSQLParser.FOR); + this.state = 4752; + this.typename(); + this.state = 4753; + this.match(PostgreSQLParser.LANGUAGE); + this.state = 4754; + this.name(); + this.state = 4755; + this.match(PostgreSQLParser.IS); + this.state = 4756; + this.comment_text(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 4758; + this.match(PostgreSQLParser.COMMENT); + this.state = 4759; + this.match(PostgreSQLParser.ON); + this.state = 4760; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4761; + this.match(PostgreSQLParser.CLASS); + this.state = 4762; + this.any_name(); + this.state = 4763; + this.match(PostgreSQLParser.USING); + this.state = 4764; + this.name(); + this.state = 4765; + this.match(PostgreSQLParser.IS); + this.state = 4766; + this.comment_text(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 4768; + this.match(PostgreSQLParser.COMMENT); + this.state = 4769; + this.match(PostgreSQLParser.ON); + this.state = 4770; + this.match(PostgreSQLParser.OPERATOR); + this.state = 4771; + this.match(PostgreSQLParser.FAMILY); + this.state = 4772; + this.any_name(); + this.state = 4773; + this.match(PostgreSQLParser.USING); + this.state = 4774; + this.name(); + this.state = 4775; + this.match(PostgreSQLParser.IS); + this.state = 4776; + this.comment_text(); + break; + + case 17: + this.enterOuterAlt(localctx, 17); + this.state = 4778; + this.match(PostgreSQLParser.COMMENT); + this.state = 4779; + this.match(PostgreSQLParser.ON); + this.state = 4780; + this.match(PostgreSQLParser.LARGE_P); + this.state = 4781; + this.match(PostgreSQLParser.OBJECT_P); + this.state = 4782; + this.numericonly(); + this.state = 4783; + this.match(PostgreSQLParser.IS); + this.state = 4784; + this.comment_text(); + break; + + case 18: + this.enterOuterAlt(localctx, 18); + this.state = 4786; + this.match(PostgreSQLParser.COMMENT); + this.state = 4787; + this.match(PostgreSQLParser.ON); + this.state = 4788; + this.match(PostgreSQLParser.CAST); + this.state = 4789; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4790; + this.typename(); + this.state = 4791; + this.match(PostgreSQLParser.AS); + this.state = 4792; + this.typename(); + this.state = 4793; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 4794; + this.match(PostgreSQLParser.IS); + this.state = 4795; + this.comment_text(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Comment_textContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_comment_text; + return this; +} + +Comment_textContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Comment_textContext.prototype.constructor = Comment_textContext; + +Comment_textContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Comment_textContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +Comment_textContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterComment_text(this); + } +}; + +Comment_textContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitComment_text(this); + } +}; + +Comment_textContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitComment_text(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Comment_textContext = Comment_textContext; + +PostgreSQLParser.prototype.comment_text = function() { + + var localctx = new Comment_textContext(this, this._ctx, this.state); + this.enterRule(localctx, 536, PostgreSQLParser.RULE_comment_text); + try { + this.state = 4801; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 4799; + this.sconst(); + break; + case PostgreSQLParser.NULL_P: + this.enterOuterAlt(localctx, 2); + this.state = 4800; + this.match(PostgreSQLParser.NULL_P); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function SeclabelstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_seclabelstmt; + return this; +} + +SeclabelstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +SeclabelstmtContext.prototype.constructor = SeclabelstmtContext; + +SeclabelstmtContext.prototype.SECURITY = function() { + return this.getToken(PostgreSQLParser.SECURITY, 0); +}; + +SeclabelstmtContext.prototype.LABEL = function() { + return this.getToken(PostgreSQLParser.LABEL, 0); +}; + +SeclabelstmtContext.prototype.opt_provider = function() { + return this.getTypedRuleContext(Opt_providerContext,0); +}; + +SeclabelstmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +SeclabelstmtContext.prototype.object_type_any_name = function() { + return this.getTypedRuleContext(Object_type_any_nameContext,0); +}; + +SeclabelstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +SeclabelstmtContext.prototype.IS = function() { + return this.getToken(PostgreSQLParser.IS, 0); +}; + +SeclabelstmtContext.prototype.security_label = function() { + return this.getTypedRuleContext(Security_labelContext,0); +}; + +SeclabelstmtContext.prototype.COLUMN = function() { + return this.getToken(PostgreSQLParser.COLUMN, 0); +}; + +SeclabelstmtContext.prototype.object_type_name = function() { + return this.getTypedRuleContext(Object_type_nameContext,0); +}; + +SeclabelstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +SeclabelstmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +SeclabelstmtContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +SeclabelstmtContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +SeclabelstmtContext.prototype.AGGREGATE = function() { + return this.getToken(PostgreSQLParser.AGGREGATE, 0); +}; + +SeclabelstmtContext.prototype.aggregate_with_argtypes = function() { + return this.getTypedRuleContext(Aggregate_with_argtypesContext,0); +}; + +SeclabelstmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +SeclabelstmtContext.prototype.function_with_argtypes = function() { + return this.getTypedRuleContext(Function_with_argtypesContext,0); +}; + +SeclabelstmtContext.prototype.LARGE_P = function() { + return this.getToken(PostgreSQLParser.LARGE_P, 0); +}; + +SeclabelstmtContext.prototype.OBJECT_P = function() { + return this.getToken(PostgreSQLParser.OBJECT_P, 0); +}; + +SeclabelstmtContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +SeclabelstmtContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +SeclabelstmtContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +SeclabelstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSeclabelstmt(this); + } +}; + +SeclabelstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSeclabelstmt(this); + } +}; + +SeclabelstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSeclabelstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.SeclabelstmtContext = SeclabelstmtContext; + +PostgreSQLParser.prototype.seclabelstmt = function() { + + var localctx = new SeclabelstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 538, PostgreSQLParser.RULE_seclabelstmt); + try { + this.state = 4894; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,229,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4803; + this.match(PostgreSQLParser.SECURITY); + this.state = 4804; + this.match(PostgreSQLParser.LABEL); + this.state = 4805; + this.opt_provider(); + this.state = 4806; + this.match(PostgreSQLParser.ON); + this.state = 4807; + this.object_type_any_name(); + this.state = 4808; + this.any_name(); + this.state = 4809; + this.match(PostgreSQLParser.IS); + this.state = 4810; + this.security_label(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4812; + this.match(PostgreSQLParser.SECURITY); + this.state = 4813; + this.match(PostgreSQLParser.LABEL); + this.state = 4814; + this.opt_provider(); + this.state = 4815; + this.match(PostgreSQLParser.ON); + this.state = 4816; + this.match(PostgreSQLParser.COLUMN); + this.state = 4817; + this.any_name(); + this.state = 4818; + this.match(PostgreSQLParser.IS); + this.state = 4819; + this.security_label(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4821; + this.match(PostgreSQLParser.SECURITY); + this.state = 4822; + this.match(PostgreSQLParser.LABEL); + this.state = 4823; + this.opt_provider(); + this.state = 4824; + this.match(PostgreSQLParser.ON); + this.state = 4825; + this.object_type_name(); + this.state = 4826; + this.name(); + this.state = 4827; + this.match(PostgreSQLParser.IS); + this.state = 4828; + this.security_label(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4830; + this.match(PostgreSQLParser.SECURITY); + this.state = 4831; + this.match(PostgreSQLParser.LABEL); + this.state = 4832; + this.opt_provider(); + this.state = 4833; + this.match(PostgreSQLParser.ON); + this.state = 4834; + this.match(PostgreSQLParser.TYPE_P); + this.state = 4835; + this.typename(); + this.state = 4836; + this.match(PostgreSQLParser.IS); + this.state = 4837; + this.security_label(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 4839; + this.match(PostgreSQLParser.SECURITY); + this.state = 4840; + this.match(PostgreSQLParser.LABEL); + this.state = 4841; + this.opt_provider(); + this.state = 4842; + this.match(PostgreSQLParser.ON); + this.state = 4843; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 4844; + this.typename(); + this.state = 4845; + this.match(PostgreSQLParser.IS); + this.state = 4846; + this.security_label(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 4848; + this.match(PostgreSQLParser.SECURITY); + this.state = 4849; + this.match(PostgreSQLParser.LABEL); + this.state = 4850; + this.opt_provider(); + this.state = 4851; + this.match(PostgreSQLParser.ON); + this.state = 4852; + this.match(PostgreSQLParser.AGGREGATE); + this.state = 4853; + this.aggregate_with_argtypes(); + this.state = 4854; + this.match(PostgreSQLParser.IS); + this.state = 4855; + this.security_label(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 4857; + this.match(PostgreSQLParser.SECURITY); + this.state = 4858; + this.match(PostgreSQLParser.LABEL); + this.state = 4859; + this.opt_provider(); + this.state = 4860; + this.match(PostgreSQLParser.ON); + this.state = 4861; + this.match(PostgreSQLParser.FUNCTION); + this.state = 4862; + this.function_with_argtypes(); + this.state = 4863; + this.match(PostgreSQLParser.IS); + this.state = 4864; + this.security_label(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 4866; + this.match(PostgreSQLParser.SECURITY); + this.state = 4867; + this.match(PostgreSQLParser.LABEL); + this.state = 4868; + this.opt_provider(); + this.state = 4869; + this.match(PostgreSQLParser.ON); + this.state = 4870; + this.match(PostgreSQLParser.LARGE_P); + this.state = 4871; + this.match(PostgreSQLParser.OBJECT_P); + this.state = 4872; + this.numericonly(); + this.state = 4873; + this.match(PostgreSQLParser.IS); + this.state = 4874; + this.security_label(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 4876; + this.match(PostgreSQLParser.SECURITY); + this.state = 4877; + this.match(PostgreSQLParser.LABEL); + this.state = 4878; + this.opt_provider(); + this.state = 4879; + this.match(PostgreSQLParser.ON); + this.state = 4880; + this.match(PostgreSQLParser.PROCEDURE); + this.state = 4881; + this.function_with_argtypes(); + this.state = 4882; + this.match(PostgreSQLParser.IS); + this.state = 4883; + this.security_label(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 4885; + this.match(PostgreSQLParser.SECURITY); + this.state = 4886; + this.match(PostgreSQLParser.LABEL); + this.state = 4887; + this.opt_provider(); + this.state = 4888; + this.match(PostgreSQLParser.ON); + this.state = 4889; + this.match(PostgreSQLParser.ROUTINE); + this.state = 4890; + this.function_with_argtypes(); + this.state = 4891; + this.match(PostgreSQLParser.IS); + this.state = 4892; + this.security_label(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_providerContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_provider; + return this; +} + +Opt_providerContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_providerContext.prototype.constructor = Opt_providerContext; + +Opt_providerContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Opt_providerContext.prototype.nonreservedword_or_sconst = function() { + return this.getTypedRuleContext(Nonreservedword_or_sconstContext,0); +}; + +Opt_providerContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_provider(this); + } +}; + +Opt_providerContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_provider(this); + } +}; + +Opt_providerContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_provider(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_providerContext = Opt_providerContext; + +PostgreSQLParser.prototype.opt_provider = function() { + + var localctx = new Opt_providerContext(this, this._ctx, this.state); + this.enterRule(localctx, 540, PostgreSQLParser.RULE_opt_provider); + try { + this.state = 4899; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FOR: + this.enterOuterAlt(localctx, 1); + this.state = 4896; + this.match(PostgreSQLParser.FOR); + this.state = 4897; + this.nonreservedword_or_sconst(); + break; + case PostgreSQLParser.ON: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Security_labelContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_security_label; + return this; +} + +Security_labelContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Security_labelContext.prototype.constructor = Security_labelContext; + +Security_labelContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Security_labelContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +Security_labelContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSecurity_label(this); + } +}; + +Security_labelContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSecurity_label(this); + } +}; + +Security_labelContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSecurity_label(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Security_labelContext = Security_labelContext; + +PostgreSQLParser.prototype.security_label = function() { + + var localctx = new Security_labelContext(this, this._ctx, this.state); + this.enterRule(localctx, 542, PostgreSQLParser.RULE_security_label); + try { + this.state = 4903; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 4901; + this.sconst(); + break; + case PostgreSQLParser.NULL_P: + this.enterOuterAlt(localctx, 2); + this.state = 4902; + this.match(PostgreSQLParser.NULL_P); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function FetchstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_fetchstmt; + return this; +} + +FetchstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +FetchstmtContext.prototype.constructor = FetchstmtContext; + +FetchstmtContext.prototype.FETCH = function() { + return this.getToken(PostgreSQLParser.FETCH, 0); +}; + +FetchstmtContext.prototype.fetch_args = function() { + return this.getTypedRuleContext(Fetch_argsContext,0); +}; + +FetchstmtContext.prototype.MOVE = function() { + return this.getToken(PostgreSQLParser.MOVE, 0); +}; + +FetchstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFetchstmt(this); + } +}; + +FetchstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFetchstmt(this); + } +}; + +FetchstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFetchstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.FetchstmtContext = FetchstmtContext; + +PostgreSQLParser.prototype.fetchstmt = function() { + + var localctx = new FetchstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 544, PostgreSQLParser.RULE_fetchstmt); + try { + this.state = 4909; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FETCH: + this.enterOuterAlt(localctx, 1); + this.state = 4905; + this.match(PostgreSQLParser.FETCH); + this.state = 4906; + this.fetch_args(); + break; + case PostgreSQLParser.MOVE: + this.enterOuterAlt(localctx, 2); + this.state = 4907; + this.match(PostgreSQLParser.MOVE); + this.state = 4908; + this.fetch_args(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Fetch_argsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_fetch_args; + return this; +} + +Fetch_argsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Fetch_argsContext.prototype.constructor = Fetch_argsContext; + +Fetch_argsContext.prototype.cursor_name = function() { + return this.getTypedRuleContext(Cursor_nameContext,0); +}; + +Fetch_argsContext.prototype.from_in = function() { + return this.getTypedRuleContext(From_inContext,0); +}; + +Fetch_argsContext.prototype.NEXT = function() { + return this.getToken(PostgreSQLParser.NEXT, 0); +}; + +Fetch_argsContext.prototype.opt_from_in = function() { + return this.getTypedRuleContext(Opt_from_inContext,0); +}; + +Fetch_argsContext.prototype.PRIOR = function() { + return this.getToken(PostgreSQLParser.PRIOR, 0); +}; + +Fetch_argsContext.prototype.FIRST_P = function() { + return this.getToken(PostgreSQLParser.FIRST_P, 0); +}; + +Fetch_argsContext.prototype.LAST_P = function() { + return this.getToken(PostgreSQLParser.LAST_P, 0); +}; + +Fetch_argsContext.prototype.ABSOLUTE_P = function() { + return this.getToken(PostgreSQLParser.ABSOLUTE_P, 0); +}; + +Fetch_argsContext.prototype.signediconst = function() { + return this.getTypedRuleContext(SignediconstContext,0); +}; + +Fetch_argsContext.prototype.RELATIVE_P = function() { + return this.getToken(PostgreSQLParser.RELATIVE_P, 0); +}; + +Fetch_argsContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Fetch_argsContext.prototype.FORWARD = function() { + return this.getToken(PostgreSQLParser.FORWARD, 0); +}; + +Fetch_argsContext.prototype.BACKWARD = function() { + return this.getToken(PostgreSQLParser.BACKWARD, 0); +}; + +Fetch_argsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFetch_args(this); + } +}; + +Fetch_argsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFetch_args(this); + } +}; + +Fetch_argsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFetch_args(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Fetch_argsContext = Fetch_argsContext; + +PostgreSQLParser.prototype.fetch_args = function() { + + var localctx = new Fetch_argsContext(this, this._ctx, this.state); + this.enterRule(localctx, 546, PostgreSQLParser.RULE_fetch_args); + try { + this.state = 4977; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,233,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4911; + this.cursor_name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 4912; + this.from_in(); + this.state = 4913; + this.cursor_name(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 4915; + this.match(PostgreSQLParser.NEXT); + this.state = 4916; + this.opt_from_in(); + this.state = 4917; + this.cursor_name(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 4919; + this.match(PostgreSQLParser.PRIOR); + this.state = 4920; + this.opt_from_in(); + this.state = 4921; + this.cursor_name(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 4923; + this.match(PostgreSQLParser.FIRST_P); + this.state = 4924; + this.opt_from_in(); + this.state = 4925; + this.cursor_name(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 4927; + this.match(PostgreSQLParser.LAST_P); + this.state = 4928; + this.opt_from_in(); + this.state = 4929; + this.cursor_name(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 4931; + this.match(PostgreSQLParser.ABSOLUTE_P); + this.state = 4932; + this.signediconst(); + this.state = 4933; + this.opt_from_in(); + this.state = 4934; + this.cursor_name(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 4936; + this.match(PostgreSQLParser.RELATIVE_P); + this.state = 4937; + this.signediconst(); + this.state = 4938; + this.opt_from_in(); + this.state = 4939; + this.cursor_name(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 4941; + this.signediconst(); + this.state = 4942; + this.opt_from_in(); + this.state = 4943; + this.cursor_name(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 4945; + this.match(PostgreSQLParser.ALL); + this.state = 4946; + this.opt_from_in(); + this.state = 4947; + this.cursor_name(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 4949; + this.match(PostgreSQLParser.FORWARD); + this.state = 4950; + this.opt_from_in(); + this.state = 4951; + this.cursor_name(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 4953; + this.match(PostgreSQLParser.FORWARD); + this.state = 4954; + this.signediconst(); + this.state = 4955; + this.opt_from_in(); + this.state = 4956; + this.cursor_name(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 4958; + this.match(PostgreSQLParser.FORWARD); + this.state = 4959; + this.match(PostgreSQLParser.ALL); + this.state = 4960; + this.opt_from_in(); + this.state = 4961; + this.cursor_name(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 4963; + this.match(PostgreSQLParser.BACKWARD); + this.state = 4964; + this.opt_from_in(); + this.state = 4965; + this.cursor_name(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 4967; + this.match(PostgreSQLParser.BACKWARD); + this.state = 4968; + this.signediconst(); + this.state = 4969; + this.opt_from_in(); + this.state = 4970; + this.cursor_name(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 4972; + this.match(PostgreSQLParser.BACKWARD); + this.state = 4973; + this.match(PostgreSQLParser.ALL); + this.state = 4974; + this.opt_from_in(); + this.state = 4975; + this.cursor_name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function From_inContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_from_in; + return this; +} + +From_inContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +From_inContext.prototype.constructor = From_inContext; + +From_inContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +From_inContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +From_inContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFrom_in(this); + } +}; + +From_inContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFrom_in(this); + } +}; + +From_inContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFrom_in(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.From_inContext = From_inContext; + +PostgreSQLParser.prototype.from_in = function() { + + var localctx = new From_inContext(this, this._ctx, this.state); + this.enterRule(localctx, 548, PostgreSQLParser.RULE_from_in); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 4979; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FROM || _la===PostgreSQLParser.IN_P)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_from_inContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_from_in; + return this; +} + +Opt_from_inContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_from_inContext.prototype.constructor = Opt_from_inContext; + +Opt_from_inContext.prototype.from_in = function() { + return this.getTypedRuleContext(From_inContext,0); +}; + +Opt_from_inContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_from_in(this); + } +}; + +Opt_from_inContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_from_in(this); + } +}; + +Opt_from_inContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_from_in(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_from_inContext = Opt_from_inContext; + +PostgreSQLParser.prototype.opt_from_in = function() { + + var localctx = new Opt_from_inContext(this, this._ctx, this.state); + this.enterRule(localctx, 550, PostgreSQLParser.RULE_opt_from_in); + try { + this.state = 4983; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FROM: + case PostgreSQLParser.IN_P: + this.enterOuterAlt(localctx, 1); + this.state = 4981; + this.from_in(); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function GrantstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_grantstmt; + return this; +} + +GrantstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +GrantstmtContext.prototype.constructor = GrantstmtContext; + +GrantstmtContext.prototype.GRANT = function() { + return this.getToken(PostgreSQLParser.GRANT, 0); +}; + +GrantstmtContext.prototype.privileges = function() { + return this.getTypedRuleContext(PrivilegesContext,0); +}; + +GrantstmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +GrantstmtContext.prototype.privilege_target = function() { + return this.getTypedRuleContext(Privilege_targetContext,0); +}; + +GrantstmtContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +GrantstmtContext.prototype.grantee_list = function() { + return this.getTypedRuleContext(Grantee_listContext,0); +}; + +GrantstmtContext.prototype.opt_grant_grant_option = function() { + return this.getTypedRuleContext(Opt_grant_grant_optionContext,0); +}; + +GrantstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGrantstmt(this); + } +}; + +GrantstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGrantstmt(this); + } +}; + +GrantstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGrantstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.GrantstmtContext = GrantstmtContext; + +PostgreSQLParser.prototype.grantstmt = function() { + + var localctx = new GrantstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 552, PostgreSQLParser.RULE_grantstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 4985; + this.match(PostgreSQLParser.GRANT); + this.state = 4986; + this.privileges(); + this.state = 4987; + this.match(PostgreSQLParser.ON); + this.state = 4988; + this.privilege_target(); + this.state = 4989; + this.match(PostgreSQLParser.TO); + this.state = 4990; + this.grantee_list(); + this.state = 4991; + this.opt_grant_grant_option(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RevokestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_revokestmt; + return this; +} + +RevokestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RevokestmtContext.prototype.constructor = RevokestmtContext; + +RevokestmtContext.prototype.REVOKE = function() { + return this.getToken(PostgreSQLParser.REVOKE, 0); +}; + +RevokestmtContext.prototype.privileges = function() { + return this.getTypedRuleContext(PrivilegesContext,0); +}; + +RevokestmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +RevokestmtContext.prototype.privilege_target = function() { + return this.getTypedRuleContext(Privilege_targetContext,0); +}; + +RevokestmtContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +RevokestmtContext.prototype.grantee_list = function() { + return this.getTypedRuleContext(Grantee_listContext,0); +}; + +RevokestmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +RevokestmtContext.prototype.GRANT = function() { + return this.getToken(PostgreSQLParser.GRANT, 0); +}; + +RevokestmtContext.prototype.OPTION = function() { + return this.getToken(PostgreSQLParser.OPTION, 0); +}; + +RevokestmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +RevokestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRevokestmt(this); + } +}; + +RevokestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRevokestmt(this); + } +}; + +RevokestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRevokestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RevokestmtContext = RevokestmtContext; + +PostgreSQLParser.prototype.revokestmt = function() { + + var localctx = new RevokestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 554, PostgreSQLParser.RULE_revokestmt); + try { + this.state = 5012; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,235,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 4993; + this.match(PostgreSQLParser.REVOKE); + this.state = 4994; + this.privileges(); + this.state = 4995; + this.match(PostgreSQLParser.ON); + this.state = 4996; + this.privilege_target(); + this.state = 4997; + this.match(PostgreSQLParser.FROM); + this.state = 4998; + this.grantee_list(); + this.state = 4999; + this.opt_drop_behavior(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5001; + this.match(PostgreSQLParser.REVOKE); + this.state = 5002; + this.match(PostgreSQLParser.GRANT); + this.state = 5003; + this.match(PostgreSQLParser.OPTION); + this.state = 5004; + this.match(PostgreSQLParser.FOR); + this.state = 5005; + this.privileges(); + this.state = 5006; + this.match(PostgreSQLParser.ON); + this.state = 5007; + this.privilege_target(); + this.state = 5008; + this.match(PostgreSQLParser.FROM); + this.state = 5009; + this.grantee_list(); + this.state = 5010; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function PrivilegesContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_privileges; + return this; +} + +PrivilegesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +PrivilegesContext.prototype.constructor = PrivilegesContext; + +PrivilegesContext.prototype.privilege_list = function() { + return this.getTypedRuleContext(Privilege_listContext,0); +}; + +PrivilegesContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +PrivilegesContext.prototype.PRIVILEGES = function() { + return this.getToken(PostgreSQLParser.PRIVILEGES, 0); +}; + +PrivilegesContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +PrivilegesContext.prototype.columnlist = function() { + return this.getTypedRuleContext(ColumnlistContext,0); +}; + +PrivilegesContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +PrivilegesContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPrivileges(this); + } +}; + +PrivilegesContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPrivileges(this); + } +}; + +PrivilegesContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPrivileges(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.PrivilegesContext = PrivilegesContext; + +PostgreSQLParser.prototype.privileges = function() { + + var localctx = new PrivilegesContext(this, this._ctx, this.state); + this.enterRule(localctx, 556, PostgreSQLParser.RULE_privileges); + try { + this.state = 5029; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,236,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5014; + this.privilege_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5015; + this.match(PostgreSQLParser.ALL); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5016; + this.match(PostgreSQLParser.ALL); + this.state = 5017; + this.match(PostgreSQLParser.PRIVILEGES); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 5018; + this.match(PostgreSQLParser.ALL); + this.state = 5019; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5020; + this.columnlist(); + this.state = 5021; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 5023; + this.match(PostgreSQLParser.ALL); + this.state = 5024; + this.match(PostgreSQLParser.PRIVILEGES); + this.state = 5025; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5026; + this.columnlist(); + this.state = 5027; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Privilege_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_privilege_list; + return this; +} + +Privilege_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Privilege_listContext.prototype.constructor = Privilege_listContext; + +Privilege_listContext.prototype.privilege = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(PrivilegeContext); + } else { + return this.getTypedRuleContext(PrivilegeContext,i); + } +}; + +Privilege_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Privilege_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPrivilege_list(this); + } +}; + +Privilege_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPrivilege_list(this); + } +}; + +Privilege_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPrivilege_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Privilege_listContext = Privilege_listContext; + +PostgreSQLParser.prototype.privilege_list = function() { + + var localctx = new Privilege_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 558, PostgreSQLParser.RULE_privilege_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5031; + this.privilege(); + this.state = 5036; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5032; + this.match(PostgreSQLParser.COMMA); + this.state = 5033; + this.privilege(); + this.state = 5038; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function PrivilegeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_privilege; + return this; +} + +PrivilegeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +PrivilegeContext.prototype.constructor = PrivilegeContext; + +PrivilegeContext.prototype.SELECT = function() { + return this.getToken(PostgreSQLParser.SELECT, 0); +}; + +PrivilegeContext.prototype.opt_column_list = function() { + return this.getTypedRuleContext(Opt_column_listContext,0); +}; + +PrivilegeContext.prototype.REFERENCES = function() { + return this.getToken(PostgreSQLParser.REFERENCES, 0); +}; + +PrivilegeContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +PrivilegeContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +PrivilegeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPrivilege(this); + } +}; + +PrivilegeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPrivilege(this); + } +}; + +PrivilegeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPrivilege(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.PrivilegeContext = PrivilegeContext; + +PostgreSQLParser.prototype.privilege = function() { + + var localctx = new PrivilegeContext(this, this._ctx, this.state); + this.enterRule(localctx, 560, PostgreSQLParser.RULE_privilege); + try { + this.state = 5048; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SELECT: + this.enterOuterAlt(localctx, 1); + this.state = 5039; + this.match(PostgreSQLParser.SELECT); + this.state = 5040; + this.opt_column_list(); + break; + case PostgreSQLParser.REFERENCES: + this.enterOuterAlt(localctx, 2); + this.state = 5041; + this.match(PostgreSQLParser.REFERENCES); + this.state = 5042; + this.opt_column_list(); + break; + case PostgreSQLParser.CREATE: + this.enterOuterAlt(localctx, 3); + this.state = 5043; + this.match(PostgreSQLParser.CREATE); + this.state = 5044; + this.opt_column_list(); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 4); + this.state = 5045; + this.colid(); + this.state = 5046; + this.opt_column_list(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Privilege_targetContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_privilege_target; + return this; +} + +Privilege_targetContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Privilege_targetContext.prototype.constructor = Privilege_targetContext; + +Privilege_targetContext.prototype.qualified_name_list = function() { + return this.getTypedRuleContext(Qualified_name_listContext,0); +}; + +Privilege_targetContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +Privilege_targetContext.prototype.SEQUENCE = function() { + return this.getToken(PostgreSQLParser.SEQUENCE, 0); +}; + +Privilege_targetContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +Privilege_targetContext.prototype.DATA_P = function() { + return this.getToken(PostgreSQLParser.DATA_P, 0); +}; + +Privilege_targetContext.prototype.WRAPPER = function() { + return this.getToken(PostgreSQLParser.WRAPPER, 0); +}; + +Privilege_targetContext.prototype.name_list = function() { + return this.getTypedRuleContext(Name_listContext,0); +}; + +Privilege_targetContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +Privilege_targetContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +Privilege_targetContext.prototype.function_with_argtypes_list = function() { + return this.getTypedRuleContext(Function_with_argtypes_listContext,0); +}; + +Privilege_targetContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +Privilege_targetContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +Privilege_targetContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +Privilege_targetContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +Privilege_targetContext.prototype.any_name_list = function() { + return this.getTypedRuleContext(Any_name_listContext,0); +}; + +Privilege_targetContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +Privilege_targetContext.prototype.LARGE_P = function() { + return this.getToken(PostgreSQLParser.LARGE_P, 0); +}; + +Privilege_targetContext.prototype.OBJECT_P = function() { + return this.getToken(PostgreSQLParser.OBJECT_P, 0); +}; + +Privilege_targetContext.prototype.numericonly_list = function() { + return this.getTypedRuleContext(Numericonly_listContext,0); +}; + +Privilege_targetContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +Privilege_targetContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +Privilege_targetContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +Privilege_targetContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Privilege_targetContext.prototype.TABLES = function() { + return this.getToken(PostgreSQLParser.TABLES, 0); +}; + +Privilege_targetContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +Privilege_targetContext.prototype.SEQUENCES = function() { + return this.getToken(PostgreSQLParser.SEQUENCES, 0); +}; + +Privilege_targetContext.prototype.FUNCTIONS = function() { + return this.getToken(PostgreSQLParser.FUNCTIONS, 0); +}; + +Privilege_targetContext.prototype.PROCEDURES = function() { + return this.getToken(PostgreSQLParser.PROCEDURES, 0); +}; + +Privilege_targetContext.prototype.ROUTINES = function() { + return this.getToken(PostgreSQLParser.ROUTINES, 0); +}; + +Privilege_targetContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPrivilege_target(this); + } +}; + +Privilege_targetContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPrivilege_target(this); + } +}; + +Privilege_targetContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPrivilege_target(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Privilege_targetContext = Privilege_targetContext; + +PostgreSQLParser.prototype.privilege_target = function() { + + var localctx = new Privilege_targetContext(this, this._ctx, this.state); + this.enterRule(localctx, 562, PostgreSQLParser.RULE_privilege_target); + try { + this.state = 5108; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,239,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5050; + this.qualified_name_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5051; + this.match(PostgreSQLParser.TABLE); + this.state = 5052; + this.qualified_name_list(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5053; + this.match(PostgreSQLParser.SEQUENCE); + this.state = 5054; + this.qualified_name_list(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 5055; + this.match(PostgreSQLParser.FOREIGN); + this.state = 5056; + this.match(PostgreSQLParser.DATA_P); + this.state = 5057; + this.match(PostgreSQLParser.WRAPPER); + this.state = 5058; + this.name_list(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 5059; + this.match(PostgreSQLParser.FOREIGN); + this.state = 5060; + this.match(PostgreSQLParser.SERVER); + this.state = 5061; + this.name_list(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 5062; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5063; + this.function_with_argtypes_list(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 5064; + this.match(PostgreSQLParser.PROCEDURE); + this.state = 5065; + this.function_with_argtypes_list(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 5066; + this.match(PostgreSQLParser.ROUTINE); + this.state = 5067; + this.function_with_argtypes_list(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 5068; + this.match(PostgreSQLParser.DATABASE); + this.state = 5069; + this.name_list(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 5070; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 5071; + this.any_name_list(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 5072; + this.match(PostgreSQLParser.LANGUAGE); + this.state = 5073; + this.name_list(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 5074; + this.match(PostgreSQLParser.LARGE_P); + this.state = 5075; + this.match(PostgreSQLParser.OBJECT_P); + this.state = 5076; + this.numericonly_list(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 5077; + this.match(PostgreSQLParser.SCHEMA); + this.state = 5078; + this.name_list(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 5079; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 5080; + this.name_list(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 5081; + this.match(PostgreSQLParser.TYPE_P); + this.state = 5082; + this.any_name_list(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 5083; + this.match(PostgreSQLParser.ALL); + this.state = 5084; + this.match(PostgreSQLParser.TABLES); + this.state = 5085; + this.match(PostgreSQLParser.IN_P); + this.state = 5086; + this.match(PostgreSQLParser.SCHEMA); + this.state = 5087; + this.name_list(); + break; + + case 17: + this.enterOuterAlt(localctx, 17); + this.state = 5088; + this.match(PostgreSQLParser.ALL); + this.state = 5089; + this.match(PostgreSQLParser.SEQUENCES); + this.state = 5090; + this.match(PostgreSQLParser.IN_P); + this.state = 5091; + this.match(PostgreSQLParser.SCHEMA); + this.state = 5092; + this.name_list(); + break; + + case 18: + this.enterOuterAlt(localctx, 18); + this.state = 5093; + this.match(PostgreSQLParser.ALL); + this.state = 5094; + this.match(PostgreSQLParser.FUNCTIONS); + this.state = 5095; + this.match(PostgreSQLParser.IN_P); + this.state = 5096; + this.match(PostgreSQLParser.SCHEMA); + this.state = 5097; + this.name_list(); + break; + + case 19: + this.enterOuterAlt(localctx, 19); + this.state = 5098; + this.match(PostgreSQLParser.ALL); + this.state = 5099; + this.match(PostgreSQLParser.PROCEDURES); + this.state = 5100; + this.match(PostgreSQLParser.IN_P); + this.state = 5101; + this.match(PostgreSQLParser.SCHEMA); + this.state = 5102; + this.name_list(); + break; + + case 20: + this.enterOuterAlt(localctx, 20); + this.state = 5103; + this.match(PostgreSQLParser.ALL); + this.state = 5104; + this.match(PostgreSQLParser.ROUTINES); + this.state = 5105; + this.match(PostgreSQLParser.IN_P); + this.state = 5106; + this.match(PostgreSQLParser.SCHEMA); + this.state = 5107; + this.name_list(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Grantee_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_grantee_list; + return this; +} + +Grantee_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Grantee_listContext.prototype.constructor = Grantee_listContext; + +Grantee_listContext.prototype.grantee = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(GranteeContext); + } else { + return this.getTypedRuleContext(GranteeContext,i); + } +}; + +Grantee_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Grantee_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGrantee_list(this); + } +}; + +Grantee_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGrantee_list(this); + } +}; + +Grantee_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGrantee_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Grantee_listContext = Grantee_listContext; + +PostgreSQLParser.prototype.grantee_list = function() { + + var localctx = new Grantee_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 564, PostgreSQLParser.RULE_grantee_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5110; + this.grantee(); + this.state = 5115; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5111; + this.match(PostgreSQLParser.COMMA); + this.state = 5112; + this.grantee(); + this.state = 5117; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function GranteeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_grantee; + return this; +} + +GranteeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +GranteeContext.prototype.constructor = GranteeContext; + +GranteeContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +GranteeContext.prototype.GROUP_P = function() { + return this.getToken(PostgreSQLParser.GROUP_P, 0); +}; + +GranteeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGrantee(this); + } +}; + +GranteeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGrantee(this); + } +}; + +GranteeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGrantee(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.GranteeContext = GranteeContext; + +PostgreSQLParser.prototype.grantee = function() { + + var localctx = new GranteeContext(this, this._ctx, this.state); + this.enterRule(localctx, 566, PostgreSQLParser.RULE_grantee); + try { + this.state = 5121; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 5118; + this.rolespec(); + break; + case PostgreSQLParser.GROUP_P: + this.enterOuterAlt(localctx, 2); + this.state = 5119; + this.match(PostgreSQLParser.GROUP_P); + this.state = 5120; + this.rolespec(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_grant_grant_optionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_grant_grant_option; + return this; +} + +Opt_grant_grant_optionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_grant_grant_optionContext.prototype.constructor = Opt_grant_grant_optionContext; + +Opt_grant_grant_optionContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Opt_grant_grant_optionContext.prototype.GRANT = function() { + return this.getToken(PostgreSQLParser.GRANT, 0); +}; + +Opt_grant_grant_optionContext.prototype.OPTION = function() { + return this.getToken(PostgreSQLParser.OPTION, 0); +}; + +Opt_grant_grant_optionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_grant_grant_option(this); + } +}; + +Opt_grant_grant_optionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_grant_grant_option(this); + } +}; + +Opt_grant_grant_optionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_grant_grant_option(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_grant_grant_optionContext = Opt_grant_grant_optionContext; + +PostgreSQLParser.prototype.opt_grant_grant_option = function() { + + var localctx = new Opt_grant_grant_optionContext(this, this._ctx, this.state); + this.enterRule(localctx, 568, PostgreSQLParser.RULE_opt_grant_grant_option); + try { + this.state = 5127; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,242,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5123; + this.match(PostgreSQLParser.WITH); + this.state = 5124; + this.match(PostgreSQLParser.GRANT); + this.state = 5125; + this.match(PostgreSQLParser.OPTION); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function GrantrolestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_grantrolestmt; + return this; +} + +GrantrolestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +GrantrolestmtContext.prototype.constructor = GrantrolestmtContext; + +GrantrolestmtContext.prototype.GRANT = function() { + return this.getToken(PostgreSQLParser.GRANT, 0); +}; + +GrantrolestmtContext.prototype.privilege_list = function() { + return this.getTypedRuleContext(Privilege_listContext,0); +}; + +GrantrolestmtContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +GrantrolestmtContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +GrantrolestmtContext.prototype.opt_grant_admin_option = function() { + return this.getTypedRuleContext(Opt_grant_admin_optionContext,0); +}; + +GrantrolestmtContext.prototype.opt_granted_by = function() { + return this.getTypedRuleContext(Opt_granted_byContext,0); +}; + +GrantrolestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGrantrolestmt(this); + } +}; + +GrantrolestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGrantrolestmt(this); + } +}; + +GrantrolestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGrantrolestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.GrantrolestmtContext = GrantrolestmtContext; + +PostgreSQLParser.prototype.grantrolestmt = function() { + + var localctx = new GrantrolestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 570, PostgreSQLParser.RULE_grantrolestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5129; + this.match(PostgreSQLParser.GRANT); + this.state = 5130; + this.privilege_list(); + this.state = 5131; + this.match(PostgreSQLParser.TO); + this.state = 5132; + this.role_list(); + this.state = 5133; + this.opt_grant_admin_option(); + this.state = 5134; + this.opt_granted_by(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RevokerolestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_revokerolestmt; + return this; +} + +RevokerolestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RevokerolestmtContext.prototype.constructor = RevokerolestmtContext; + +RevokerolestmtContext.prototype.REVOKE = function() { + return this.getToken(PostgreSQLParser.REVOKE, 0); +}; + +RevokerolestmtContext.prototype.privilege_list = function() { + return this.getTypedRuleContext(Privilege_listContext,0); +}; + +RevokerolestmtContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +RevokerolestmtContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +RevokerolestmtContext.prototype.opt_granted_by = function() { + return this.getTypedRuleContext(Opt_granted_byContext,0); +}; + +RevokerolestmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +RevokerolestmtContext.prototype.ADMIN = function() { + return this.getToken(PostgreSQLParser.ADMIN, 0); +}; + +RevokerolestmtContext.prototype.OPTION = function() { + return this.getToken(PostgreSQLParser.OPTION, 0); +}; + +RevokerolestmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +RevokerolestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRevokerolestmt(this); + } +}; + +RevokerolestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRevokerolestmt(this); + } +}; + +RevokerolestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRevokerolestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RevokerolestmtContext = RevokerolestmtContext; + +PostgreSQLParser.prototype.revokerolestmt = function() { + + var localctx = new RevokerolestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 572, PostgreSQLParser.RULE_revokerolestmt); + try { + this.state = 5153; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,243,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5136; + this.match(PostgreSQLParser.REVOKE); + this.state = 5137; + this.privilege_list(); + this.state = 5138; + this.match(PostgreSQLParser.FROM); + this.state = 5139; + this.role_list(); + this.state = 5140; + this.opt_granted_by(); + this.state = 5141; + this.opt_drop_behavior(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5143; + this.match(PostgreSQLParser.REVOKE); + this.state = 5144; + this.match(PostgreSQLParser.ADMIN); + this.state = 5145; + this.match(PostgreSQLParser.OPTION); + this.state = 5146; + this.match(PostgreSQLParser.FOR); + this.state = 5147; + this.privilege_list(); + this.state = 5148; + this.match(PostgreSQLParser.FROM); + this.state = 5149; + this.role_list(); + this.state = 5150; + this.opt_granted_by(); + this.state = 5151; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_grant_admin_optionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_grant_admin_option; + return this; +} + +Opt_grant_admin_optionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_grant_admin_optionContext.prototype.constructor = Opt_grant_admin_optionContext; + +Opt_grant_admin_optionContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Opt_grant_admin_optionContext.prototype.ADMIN = function() { + return this.getToken(PostgreSQLParser.ADMIN, 0); +}; + +Opt_grant_admin_optionContext.prototype.OPTION = function() { + return this.getToken(PostgreSQLParser.OPTION, 0); +}; + +Opt_grant_admin_optionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_grant_admin_option(this); + } +}; + +Opt_grant_admin_optionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_grant_admin_option(this); + } +}; + +Opt_grant_admin_optionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_grant_admin_option(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_grant_admin_optionContext = Opt_grant_admin_optionContext; + +PostgreSQLParser.prototype.opt_grant_admin_option = function() { + + var localctx = new Opt_grant_admin_optionContext(this, this._ctx, this.state); + this.enterRule(localctx, 574, PostgreSQLParser.RULE_opt_grant_admin_option); + try { + this.state = 5159; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,244,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5155; + this.match(PostgreSQLParser.WITH); + this.state = 5156; + this.match(PostgreSQLParser.ADMIN); + this.state = 5157; + this.match(PostgreSQLParser.OPTION); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_granted_byContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_granted_by; + return this; +} + +Opt_granted_byContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_granted_byContext.prototype.constructor = Opt_granted_byContext; + +Opt_granted_byContext.prototype.GRANTED = function() { + return this.getToken(PostgreSQLParser.GRANTED, 0); +}; + +Opt_granted_byContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Opt_granted_byContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +Opt_granted_byContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_granted_by(this); + } +}; + +Opt_granted_byContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_granted_by(this); + } +}; + +Opt_granted_byContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_granted_by(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_granted_byContext = Opt_granted_byContext; + +PostgreSQLParser.prototype.opt_granted_by = function() { + + var localctx = new Opt_granted_byContext(this, this._ctx, this.state); + this.enterRule(localctx, 576, PostgreSQLParser.RULE_opt_granted_by); + try { + this.state = 5165; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.GRANTED: + this.enterOuterAlt(localctx, 1); + this.state = 5161; + this.match(PostgreSQLParser.GRANTED); + this.state = 5162; + this.match(PostgreSQLParser.BY); + this.state = 5163; + this.rolespec(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterdefaultprivilegesstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterdefaultprivilegesstmt; + return this; +} + +AlterdefaultprivilegesstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterdefaultprivilegesstmtContext.prototype.constructor = AlterdefaultprivilegesstmtContext; + +AlterdefaultprivilegesstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterdefaultprivilegesstmtContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +AlterdefaultprivilegesstmtContext.prototype.PRIVILEGES = function() { + return this.getToken(PostgreSQLParser.PRIVILEGES, 0); +}; + +AlterdefaultprivilegesstmtContext.prototype.defacloptionlist = function() { + return this.getTypedRuleContext(DefacloptionlistContext,0); +}; + +AlterdefaultprivilegesstmtContext.prototype.defaclaction = function() { + return this.getTypedRuleContext(DefaclactionContext,0); +}; + +AlterdefaultprivilegesstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterdefaultprivilegesstmt(this); + } +}; + +AlterdefaultprivilegesstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterdefaultprivilegesstmt(this); + } +}; + +AlterdefaultprivilegesstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterdefaultprivilegesstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterdefaultprivilegesstmtContext = AlterdefaultprivilegesstmtContext; + +PostgreSQLParser.prototype.alterdefaultprivilegesstmt = function() { + + var localctx = new AlterdefaultprivilegesstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 578, PostgreSQLParser.RULE_alterdefaultprivilegesstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5167; + this.match(PostgreSQLParser.ALTER); + this.state = 5168; + this.match(PostgreSQLParser.DEFAULT); + this.state = 5169; + this.match(PostgreSQLParser.PRIVILEGES); + this.state = 5170; + this.defacloptionlist(); + this.state = 5171; + this.defaclaction(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DefacloptionlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_defacloptionlist; + return this; +} + +DefacloptionlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DefacloptionlistContext.prototype.constructor = DefacloptionlistContext; + +DefacloptionlistContext.prototype.defacloption = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(DefacloptionContext); + } else { + return this.getTypedRuleContext(DefacloptionContext,i); + } +}; + +DefacloptionlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDefacloptionlist(this); + } +}; + +DefacloptionlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDefacloptionlist(this); + } +}; + +DefacloptionlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDefacloptionlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DefacloptionlistContext = DefacloptionlistContext; + +PostgreSQLParser.prototype.defacloptionlist = function() { + + var localctx = new DefacloptionlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 580, PostgreSQLParser.RULE_defacloptionlist); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5176; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.FOR || _la===PostgreSQLParser.IN_P) { + this.state = 5173; + this.defacloption(); + this.state = 5178; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DefacloptionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_defacloption; + return this; +} + +DefacloptionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DefacloptionContext.prototype.constructor = DefacloptionContext; + +DefacloptionContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +DefacloptionContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +DefacloptionContext.prototype.name_list = function() { + return this.getTypedRuleContext(Name_listContext,0); +}; + +DefacloptionContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +DefacloptionContext.prototype.ROLE = function() { + return this.getToken(PostgreSQLParser.ROLE, 0); +}; + +DefacloptionContext.prototype.role_list = function() { + return this.getTypedRuleContext(Role_listContext,0); +}; + +DefacloptionContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +DefacloptionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDefacloption(this); + } +}; + +DefacloptionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDefacloption(this); + } +}; + +DefacloptionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDefacloption(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DefacloptionContext = DefacloptionContext; + +PostgreSQLParser.prototype.defacloption = function() { + + var localctx = new DefacloptionContext(this, this._ctx, this.state); + this.enterRule(localctx, 582, PostgreSQLParser.RULE_defacloption); + try { + this.state = 5188; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,247,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5179; + this.match(PostgreSQLParser.IN_P); + this.state = 5180; + this.match(PostgreSQLParser.SCHEMA); + this.state = 5181; + this.name_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5182; + this.match(PostgreSQLParser.FOR); + this.state = 5183; + this.match(PostgreSQLParser.ROLE); + this.state = 5184; + this.role_list(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5185; + this.match(PostgreSQLParser.FOR); + this.state = 5186; + this.match(PostgreSQLParser.USER); + this.state = 5187; + this.role_list(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DefaclactionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_defaclaction; + return this; +} + +DefaclactionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DefaclactionContext.prototype.constructor = DefaclactionContext; + +DefaclactionContext.prototype.GRANT = function() { + return this.getToken(PostgreSQLParser.GRANT, 0); +}; + +DefaclactionContext.prototype.privileges = function() { + return this.getTypedRuleContext(PrivilegesContext,0); +}; + +DefaclactionContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +DefaclactionContext.prototype.defacl_privilege_target = function() { + return this.getTypedRuleContext(Defacl_privilege_targetContext,0); +}; + +DefaclactionContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +DefaclactionContext.prototype.grantee_list = function() { + return this.getTypedRuleContext(Grantee_listContext,0); +}; + +DefaclactionContext.prototype.opt_grant_grant_option = function() { + return this.getTypedRuleContext(Opt_grant_grant_optionContext,0); +}; + +DefaclactionContext.prototype.REVOKE = function() { + return this.getToken(PostgreSQLParser.REVOKE, 0); +}; + +DefaclactionContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +DefaclactionContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +DefaclactionContext.prototype.OPTION = function() { + return this.getToken(PostgreSQLParser.OPTION, 0); +}; + +DefaclactionContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +DefaclactionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDefaclaction(this); + } +}; + +DefaclactionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDefaclaction(this); + } +}; + +DefaclactionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDefaclaction(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DefaclactionContext = DefaclactionContext; + +PostgreSQLParser.prototype.defaclaction = function() { + + var localctx = new DefaclactionContext(this, this._ctx, this.state); + this.enterRule(localctx, 584, PostgreSQLParser.RULE_defaclaction); + try { + this.state = 5217; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,248,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5190; + this.match(PostgreSQLParser.GRANT); + this.state = 5191; + this.privileges(); + this.state = 5192; + this.match(PostgreSQLParser.ON); + this.state = 5193; + this.defacl_privilege_target(); + this.state = 5194; + this.match(PostgreSQLParser.TO); + this.state = 5195; + this.grantee_list(); + this.state = 5196; + this.opt_grant_grant_option(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5198; + this.match(PostgreSQLParser.REVOKE); + this.state = 5199; + this.privileges(); + this.state = 5200; + this.match(PostgreSQLParser.ON); + this.state = 5201; + this.defacl_privilege_target(); + this.state = 5202; + this.match(PostgreSQLParser.FROM); + this.state = 5203; + this.grantee_list(); + this.state = 5204; + this.opt_drop_behavior(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5206; + this.match(PostgreSQLParser.REVOKE); + this.state = 5207; + this.match(PostgreSQLParser.GRANT); + this.state = 5208; + this.match(PostgreSQLParser.OPTION); + this.state = 5209; + this.match(PostgreSQLParser.FOR); + this.state = 5210; + this.privileges(); + this.state = 5211; + this.match(PostgreSQLParser.ON); + this.state = 5212; + this.defacl_privilege_target(); + this.state = 5213; + this.match(PostgreSQLParser.FROM); + this.state = 5214; + this.grantee_list(); + this.state = 5215; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Defacl_privilege_targetContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_defacl_privilege_target; + return this; +} + +Defacl_privilege_targetContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Defacl_privilege_targetContext.prototype.constructor = Defacl_privilege_targetContext; + +Defacl_privilege_targetContext.prototype.TABLES = function() { + return this.getToken(PostgreSQLParser.TABLES, 0); +}; + +Defacl_privilege_targetContext.prototype.FUNCTIONS = function() { + return this.getToken(PostgreSQLParser.FUNCTIONS, 0); +}; + +Defacl_privilege_targetContext.prototype.ROUTINES = function() { + return this.getToken(PostgreSQLParser.ROUTINES, 0); +}; + +Defacl_privilege_targetContext.prototype.SEQUENCES = function() { + return this.getToken(PostgreSQLParser.SEQUENCES, 0); +}; + +Defacl_privilege_targetContext.prototype.TYPES_P = function() { + return this.getToken(PostgreSQLParser.TYPES_P, 0); +}; + +Defacl_privilege_targetContext.prototype.SCHEMAS = function() { + return this.getToken(PostgreSQLParser.SCHEMAS, 0); +}; + +Defacl_privilege_targetContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDefacl_privilege_target(this); + } +}; + +Defacl_privilege_targetContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDefacl_privilege_target(this); + } +}; + +Defacl_privilege_targetContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDefacl_privilege_target(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Defacl_privilege_targetContext = Defacl_privilege_targetContext; + +PostgreSQLParser.prototype.defacl_privilege_target = function() { + + var localctx = new Defacl_privilege_targetContext(this, this._ctx, this.state); + this.enterRule(localctx, 586, PostgreSQLParser.RULE_defacl_privilege_target); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5219; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FUNCTIONS || _la===PostgreSQLParser.SEQUENCES || _la===PostgreSQLParser.TABLES || _la===PostgreSQLParser.TYPES_P || _la===PostgreSQLParser.ROUTINES || _la===PostgreSQLParser.SCHEMAS)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function IndexstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_indexstmt; + return this; +} + +IndexstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +IndexstmtContext.prototype.constructor = IndexstmtContext; + +IndexstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +IndexstmtContext.prototype.opt_unique = function() { + return this.getTypedRuleContext(Opt_uniqueContext,0); +}; + +IndexstmtContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +IndexstmtContext.prototype.opt_concurrently = function() { + return this.getTypedRuleContext(Opt_concurrentlyContext,0); +}; + +IndexstmtContext.prototype.opt_index_name = function() { + return this.getTypedRuleContext(Opt_index_nameContext,0); +}; + +IndexstmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +IndexstmtContext.prototype.relation_expr = function() { + return this.getTypedRuleContext(Relation_exprContext,0); +}; + +IndexstmtContext.prototype.access_method_clause = function() { + return this.getTypedRuleContext(Access_method_clauseContext,0); +}; + +IndexstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +IndexstmtContext.prototype.index_params = function() { + return this.getTypedRuleContext(Index_paramsContext,0); +}; + +IndexstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +IndexstmtContext.prototype.opt_include = function() { + return this.getTypedRuleContext(Opt_includeContext,0); +}; + +IndexstmtContext.prototype.opt_reloptions = function() { + return this.getTypedRuleContext(Opt_reloptionsContext,0); +}; + +IndexstmtContext.prototype.opttablespace = function() { + return this.getTypedRuleContext(OpttablespaceContext,0); +}; + +IndexstmtContext.prototype.where_clause = function() { + return this.getTypedRuleContext(Where_clauseContext,0); +}; + +IndexstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +IndexstmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +IndexstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +IndexstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +IndexstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIndexstmt(this); + } +}; + +IndexstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIndexstmt(this); + } +}; + +IndexstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIndexstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.IndexstmtContext = IndexstmtContext; + +PostgreSQLParser.prototype.indexstmt = function() { + + var localctx = new IndexstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 588, PostgreSQLParser.RULE_indexstmt); + try { + this.state = 5256; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,249,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5221; + this.match(PostgreSQLParser.CREATE); + this.state = 5222; + this.opt_unique(); + this.state = 5223; + this.match(PostgreSQLParser.INDEX); + this.state = 5224; + this.opt_concurrently(); + this.state = 5225; + this.opt_index_name(); + this.state = 5226; + this.match(PostgreSQLParser.ON); + this.state = 5227; + this.relation_expr(); + this.state = 5228; + this.access_method_clause(); + this.state = 5229; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5230; + this.index_params(); + this.state = 5231; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 5232; + this.opt_include(); + this.state = 5233; + this.opt_reloptions(); + this.state = 5234; + this.opttablespace(); + this.state = 5235; + this.where_clause(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5237; + this.match(PostgreSQLParser.CREATE); + this.state = 5238; + this.opt_unique(); + this.state = 5239; + this.match(PostgreSQLParser.INDEX); + this.state = 5240; + this.opt_concurrently(); + this.state = 5241; + this.match(PostgreSQLParser.IF_P); + this.state = 5242; + this.match(PostgreSQLParser.NOT); + this.state = 5243; + this.match(PostgreSQLParser.EXISTS); + this.state = 5244; + this.name(); + this.state = 5245; + this.match(PostgreSQLParser.ON); + this.state = 5246; + this.relation_expr(); + this.state = 5247; + this.access_method_clause(); + this.state = 5248; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5249; + this.index_params(); + this.state = 5250; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 5251; + this.opt_include(); + this.state = 5252; + this.opt_reloptions(); + this.state = 5253; + this.opttablespace(); + this.state = 5254; + this.where_clause(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_uniqueContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_unique; + return this; +} + +Opt_uniqueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_uniqueContext.prototype.constructor = Opt_uniqueContext; + +Opt_uniqueContext.prototype.UNIQUE = function() { + return this.getToken(PostgreSQLParser.UNIQUE, 0); +}; + +Opt_uniqueContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_unique(this); + } +}; + +Opt_uniqueContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_unique(this); + } +}; + +Opt_uniqueContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_unique(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_uniqueContext = Opt_uniqueContext; + +PostgreSQLParser.prototype.opt_unique = function() { + + var localctx = new Opt_uniqueContext(this, this._ctx, this.state); + this.enterRule(localctx, 590, PostgreSQLParser.RULE_opt_unique); + try { + this.state = 5260; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.UNIQUE: + this.enterOuterAlt(localctx, 1); + this.state = 5258; + this.match(PostgreSQLParser.UNIQUE); + break; + case PostgreSQLParser.INDEX: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_concurrentlyContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_concurrently; + return this; +} + +Opt_concurrentlyContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_concurrentlyContext.prototype.constructor = Opt_concurrentlyContext; + +Opt_concurrentlyContext.prototype.CONCURRENTLY = function() { + return this.getToken(PostgreSQLParser.CONCURRENTLY, 0); +}; + +Opt_concurrentlyContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_concurrently(this); + } +}; + +Opt_concurrentlyContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_concurrently(this); + } +}; + +Opt_concurrentlyContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_concurrently(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_concurrentlyContext = Opt_concurrentlyContext; + +PostgreSQLParser.prototype.opt_concurrently = function() { + + var localctx = new Opt_concurrentlyContext(this, this._ctx, this.state); + this.enterRule(localctx, 592, PostgreSQLParser.RULE_opt_concurrently); + try { + this.state = 5264; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CONCURRENTLY: + this.enterOuterAlt(localctx, 1); + this.state = 5262; + this.match(PostgreSQLParser.CONCURRENTLY); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.ON: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_index_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_index_name; + return this; +} + +Opt_index_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_index_nameContext.prototype.constructor = Opt_index_nameContext; + +Opt_index_nameContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Opt_index_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_index_name(this); + } +}; + +Opt_index_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_index_name(this); + } +}; + +Opt_index_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_index_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_index_nameContext = Opt_index_nameContext; + +PostgreSQLParser.prototype.opt_index_name = function() { + + var localctx = new Opt_index_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 594, PostgreSQLParser.RULE_opt_index_name); + try { + this.state = 5268; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 5266; + this.name(); + break; + case PostgreSQLParser.ON: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Access_method_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_access_method_clause; + return this; +} + +Access_method_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Access_method_clauseContext.prototype.constructor = Access_method_clauseContext; + +Access_method_clauseContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Access_method_clauseContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Access_method_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAccess_method_clause(this); + } +}; + +Access_method_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAccess_method_clause(this); + } +}; + +Access_method_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAccess_method_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Access_method_clauseContext = Access_method_clauseContext; + +PostgreSQLParser.prototype.access_method_clause = function() { + + var localctx = new Access_method_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 596, PostgreSQLParser.RULE_access_method_clause); + try { + this.state = 5273; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + this.state = 5270; + this.match(PostgreSQLParser.USING); + this.state = 5271; + this.name(); + break; + case PostgreSQLParser.OPEN_PAREN: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Index_paramsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_index_params; + return this; +} + +Index_paramsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Index_paramsContext.prototype.constructor = Index_paramsContext; + +Index_paramsContext.prototype.index_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Index_elemContext); + } else { + return this.getTypedRuleContext(Index_elemContext,i); + } +}; + +Index_paramsContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Index_paramsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIndex_params(this); + } +}; + +Index_paramsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIndex_params(this); + } +}; + +Index_paramsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIndex_params(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Index_paramsContext = Index_paramsContext; + +PostgreSQLParser.prototype.index_params = function() { + + var localctx = new Index_paramsContext(this, this._ctx, this.state); + this.enterRule(localctx, 598, PostgreSQLParser.RULE_index_params); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5275; + this.index_elem(); + this.state = 5280; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5276; + this.match(PostgreSQLParser.COMMA); + this.state = 5277; + this.index_elem(); + this.state = 5282; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Index_elem_optionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_index_elem_options; + return this; +} + +Index_elem_optionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Index_elem_optionsContext.prototype.constructor = Index_elem_optionsContext; + +Index_elem_optionsContext.prototype.opt_collate = function() { + return this.getTypedRuleContext(Opt_collateContext,0); +}; + +Index_elem_optionsContext.prototype.opt_class = function() { + return this.getTypedRuleContext(Opt_classContext,0); +}; + +Index_elem_optionsContext.prototype.opt_asc_desc = function() { + return this.getTypedRuleContext(Opt_asc_descContext,0); +}; + +Index_elem_optionsContext.prototype.opt_nulls_order = function() { + return this.getTypedRuleContext(Opt_nulls_orderContext,0); +}; + +Index_elem_optionsContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Index_elem_optionsContext.prototype.reloptions = function() { + return this.getTypedRuleContext(ReloptionsContext,0); +}; + +Index_elem_optionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIndex_elem_options(this); + } +}; + +Index_elem_optionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIndex_elem_options(this); + } +}; + +Index_elem_optionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIndex_elem_options(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Index_elem_optionsContext = Index_elem_optionsContext; + +PostgreSQLParser.prototype.index_elem_options = function() { + + var localctx = new Index_elem_optionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 600, PostgreSQLParser.RULE_index_elem_options); + try { + this.state = 5294; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,255,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5283; + this.opt_collate(); + this.state = 5284; + this.opt_class(); + this.state = 5285; + this.opt_asc_desc(); + this.state = 5286; + this.opt_nulls_order(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5288; + this.opt_collate(); + this.state = 5289; + this.any_name(); + this.state = 5290; + this.reloptions(); + this.state = 5291; + this.opt_asc_desc(); + this.state = 5292; + this.opt_nulls_order(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Index_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_index_elem; + return this; +} + +Index_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Index_elemContext.prototype.constructor = Index_elemContext; + +Index_elemContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Index_elemContext.prototype.index_elem_options = function() { + return this.getTypedRuleContext(Index_elem_optionsContext,0); +}; + +Index_elemContext.prototype.func_expr_windowless = function() { + return this.getTypedRuleContext(Func_expr_windowlessContext,0); +}; + +Index_elemContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Index_elemContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Index_elemContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Index_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIndex_elem(this); + } +}; + +Index_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIndex_elem(this); + } +}; + +Index_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIndex_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Index_elemContext = Index_elemContext; + +PostgreSQLParser.prototype.index_elem = function() { + + var localctx = new Index_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 602, PostgreSQLParser.RULE_index_elem); + try { + this.state = 5307; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,256,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5296; + this.colid(); + this.state = 5297; + this.index_elem_options(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5299; + this.func_expr_windowless(); + this.state = 5300; + this.index_elem_options(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5302; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5303; + this.a_expr(); + this.state = 5304; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 5305; + this.index_elem_options(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_includeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_include; + return this; +} + +Opt_includeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_includeContext.prototype.constructor = Opt_includeContext; + +Opt_includeContext.prototype.INCLUDE = function() { + return this.getToken(PostgreSQLParser.INCLUDE, 0); +}; + +Opt_includeContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opt_includeContext.prototype.index_including_params = function() { + return this.getTypedRuleContext(Index_including_paramsContext,0); +}; + +Opt_includeContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opt_includeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_include(this); + } +}; + +Opt_includeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_include(this); + } +}; + +Opt_includeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_include(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_includeContext = Opt_includeContext; + +PostgreSQLParser.prototype.opt_include = function() { + + var localctx = new Opt_includeContext(this, this._ctx, this.state); + this.enterRule(localctx, 604, PostgreSQLParser.RULE_opt_include); + try { + this.state = 5315; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.INCLUDE: + this.enterOuterAlt(localctx, 1); + this.state = 5309; + this.match(PostgreSQLParser.INCLUDE); + this.state = 5310; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5311; + this.index_including_params(); + this.state = 5312; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Index_including_paramsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_index_including_params; + return this; +} + +Index_including_paramsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Index_including_paramsContext.prototype.constructor = Index_including_paramsContext; + +Index_including_paramsContext.prototype.index_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Index_elemContext); + } else { + return this.getTypedRuleContext(Index_elemContext,i); + } +}; + +Index_including_paramsContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Index_including_paramsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIndex_including_params(this); + } +}; + +Index_including_paramsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIndex_including_params(this); + } +}; + +Index_including_paramsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIndex_including_params(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Index_including_paramsContext = Index_including_paramsContext; + +PostgreSQLParser.prototype.index_including_params = function() { + + var localctx = new Index_including_paramsContext(this, this._ctx, this.state); + this.enterRule(localctx, 606, PostgreSQLParser.RULE_index_including_params); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5317; + this.index_elem(); + this.state = 5322; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5318; + this.match(PostgreSQLParser.COMMA); + this.state = 5319; + this.index_elem(); + this.state = 5324; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_collateContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_collate; + return this; +} + +Opt_collateContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_collateContext.prototype.constructor = Opt_collateContext; + +Opt_collateContext.prototype.COLLATE = function() { + return this.getToken(PostgreSQLParser.COLLATE, 0); +}; + +Opt_collateContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Opt_collateContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_collate(this); + } +}; + +Opt_collateContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_collate(this); + } +}; + +Opt_collateContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_collate(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_collateContext = Opt_collateContext; + +PostgreSQLParser.prototype.opt_collate = function() { + + var localctx = new Opt_collateContext(this, this._ctx, this.state); + this.enterRule(localctx, 608, PostgreSQLParser.RULE_opt_collate); + try { + this.state = 5328; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,259,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5325; + this.match(PostgreSQLParser.COLLATE); + this.state = 5326; + this.any_name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_classContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_class; + return this; +} + +Opt_classContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_classContext.prototype.constructor = Opt_classContext; + +Opt_classContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Opt_classContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_class(this); + } +}; + +Opt_classContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_class(this); + } +}; + +Opt_classContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_class(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_classContext = Opt_classContext; + +PostgreSQLParser.prototype.opt_class = function() { + + var localctx = new Opt_classContext(this, this._ctx, this.state); + this.enterRule(localctx, 610, PostgreSQLParser.RULE_opt_class); + try { + this.state = 5332; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,260,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5330; + this.any_name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_asc_descContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_asc_desc; + return this; +} + +Opt_asc_descContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_asc_descContext.prototype.constructor = Opt_asc_descContext; + +Opt_asc_descContext.prototype.ASC = function() { + return this.getToken(PostgreSQLParser.ASC, 0); +}; + +Opt_asc_descContext.prototype.DESC = function() { + return this.getToken(PostgreSQLParser.DESC, 0); +}; + +Opt_asc_descContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_asc_desc(this); + } +}; + +Opt_asc_descContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_asc_desc(this); + } +}; + +Opt_asc_descContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_asc_desc(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_asc_descContext = Opt_asc_descContext; + +PostgreSQLParser.prototype.opt_asc_desc = function() { + + var localctx = new Opt_asc_descContext(this, this._ctx, this.state); + this.enterRule(localctx, 612, PostgreSQLParser.RULE_opt_asc_desc); + try { + this.state = 5337; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ASC: + this.enterOuterAlt(localctx, 1); + this.state = 5334; + this.match(PostgreSQLParser.ASC); + break; + case PostgreSQLParser.DESC: + this.enterOuterAlt(localctx, 2); + this.state = 5335; + this.match(PostgreSQLParser.DESC); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_nulls_orderContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_nulls_order; + return this; +} + +Opt_nulls_orderContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_nulls_orderContext.prototype.constructor = Opt_nulls_orderContext; + +Opt_nulls_orderContext.prototype.NULLS_P = function() { + return this.getToken(PostgreSQLParser.NULLS_P, 0); +}; + +Opt_nulls_orderContext.prototype.FIRST_P = function() { + return this.getToken(PostgreSQLParser.FIRST_P, 0); +}; + +Opt_nulls_orderContext.prototype.LAST_P = function() { + return this.getToken(PostgreSQLParser.LAST_P, 0); +}; + +Opt_nulls_orderContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_nulls_order(this); + } +}; + +Opt_nulls_orderContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_nulls_order(this); + } +}; + +Opt_nulls_orderContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_nulls_order(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_nulls_orderContext = Opt_nulls_orderContext; + +PostgreSQLParser.prototype.opt_nulls_order = function() { + + var localctx = new Opt_nulls_orderContext(this, this._ctx, this.state); + this.enterRule(localctx, 614, PostgreSQLParser.RULE_opt_nulls_order); + try { + this.state = 5344; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,262,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5339; + this.match(PostgreSQLParser.NULLS_P); + this.state = 5340; + this.match(PostgreSQLParser.FIRST_P); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5341; + this.match(PostgreSQLParser.NULLS_P); + this.state = 5342; + this.match(PostgreSQLParser.LAST_P); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatefunctionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createfunctionstmt; + return this; +} + +CreatefunctionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatefunctionstmtContext.prototype.constructor = CreatefunctionstmtContext; + +CreatefunctionstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatefunctionstmtContext.prototype.opt_or_replace = function() { + return this.getTypedRuleContext(Opt_or_replaceContext,0); +}; + +CreatefunctionstmtContext.prototype.func_name = function() { + return this.getTypedRuleContext(Func_nameContext,0); +}; + +CreatefunctionstmtContext.prototype.func_args_with_defaults = function() { + return this.getTypedRuleContext(Func_args_with_defaultsContext,0); +}; + +CreatefunctionstmtContext.prototype.createfunc_opt_list = function() { + return this.getTypedRuleContext(Createfunc_opt_listContext,0); +}; + +CreatefunctionstmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +CreatefunctionstmtContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +CreatefunctionstmtContext.prototype.RETURNS = function() { + return this.getToken(PostgreSQLParser.RETURNS, 0); +}; + +CreatefunctionstmtContext.prototype.func_return = function() { + return this.getTypedRuleContext(Func_returnContext,0); +}; + +CreatefunctionstmtContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +CreatefunctionstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CreatefunctionstmtContext.prototype.table_func_column_list = function() { + return this.getTypedRuleContext(Table_func_column_listContext,0); +}; + +CreatefunctionstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CreatefunctionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatefunctionstmt(this); + } +}; + +CreatefunctionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatefunctionstmt(this); + } +}; + +CreatefunctionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatefunctionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatefunctionstmtContext = CreatefunctionstmtContext; + +PostgreSQLParser.prototype.createfunctionstmt = function() { + + var localctx = new CreatefunctionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 616, PostgreSQLParser.RULE_createfunctionstmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5346; + this.match(PostgreSQLParser.CREATE); + this.state = 5347; + this.opt_or_replace(); + this.state = 5348; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FUNCTION || _la===PostgreSQLParser.PROCEDURE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 5349; + this.func_name(); + this.state = 5350; + this.func_args_with_defaults(); + this.state = 5360; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,264,this._ctx); + if(la_===1) { + this.state = 5351; + this.match(PostgreSQLParser.RETURNS); + this.state = 5358; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,263,this._ctx); + switch(la_) { + case 1: + this.state = 5352; + this.func_return(); + break; + + case 2: + this.state = 5353; + this.match(PostgreSQLParser.TABLE); + this.state = 5354; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5355; + this.table_func_column_list(); + this.state = 5356; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + + } + this.state = 5362; + this.createfunc_opt_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_or_replaceContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_or_replace; + return this; +} + +Opt_or_replaceContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_or_replaceContext.prototype.constructor = Opt_or_replaceContext; + +Opt_or_replaceContext.prototype.OR = function() { + return this.getToken(PostgreSQLParser.OR, 0); +}; + +Opt_or_replaceContext.prototype.REPLACE = function() { + return this.getToken(PostgreSQLParser.REPLACE, 0); +}; + +Opt_or_replaceContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_or_replace(this); + } +}; + +Opt_or_replaceContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_or_replace(this); + } +}; + +Opt_or_replaceContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_or_replace(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_or_replaceContext = Opt_or_replaceContext; + +PostgreSQLParser.prototype.opt_or_replace = function() { + + var localctx = new Opt_or_replaceContext(this, this._ctx, this.state); + this.enterRule(localctx, 618, PostgreSQLParser.RULE_opt_or_replace); + try { + this.state = 5367; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OR: + this.enterOuterAlt(localctx, 1); + this.state = 5364; + this.match(PostgreSQLParser.OR); + this.state = 5365; + this.match(PostgreSQLParser.REPLACE); + break; + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.RULE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TRANSFORM: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_argsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_args; + return this; +} + +Func_argsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_argsContext.prototype.constructor = Func_argsContext; + +Func_argsContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Func_argsContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Func_argsContext.prototype.func_args_list = function() { + return this.getTypedRuleContext(Func_args_listContext,0); +}; + +Func_argsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_args(this); + } +}; + +Func_argsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_args(this); + } +}; + +Func_argsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_args(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_argsContext = Func_argsContext; + +PostgreSQLParser.prototype.func_args = function() { + + var localctx = new Func_argsContext(this, this._ctx, this.state); + this.enterRule(localctx, 620, PostgreSQLParser.RULE_func_args); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5369; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5371; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(((((_la - 33)) & ~0x1f) == 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.AND - 33)) | (1 << (PostgreSQLParser.ARRAY - 33)) | (1 << (PostgreSQLParser.COLLATE - 33)) | (1 << (PostgreSQLParser.COLUMN - 33)) | (1 << (PostgreSQLParser.CONSTRAINT - 33)) | (1 << (PostgreSQLParser.DEFAULT - 33)) | (1 << (PostgreSQLParser.DO - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || _la===PostgreSQLParser.IN_P || _la===PostgreSQLParser.TABLE || ((((_la - 101)) & ~0x1f) == 0 && ((1 << (_la - 101)) & ((1 << (PostgreSQLParser.VARIADIC - 101)) | (1 << (PostgreSQLParser.AUTHORIZATION - 101)) | (1 << (PostgreSQLParser.BINARY - 101)) | (1 << (PostgreSQLParser.COLLATION - 101)) | (1 << (PostgreSQLParser.CONCURRENTLY - 101)) | (1 << (PostgreSQLParser.CROSS - 101)) | (1 << (PostgreSQLParser.CURRENT_SCHEMA - 101)) | (1 << (PostgreSQLParser.FREEZE - 101)) | (1 << (PostgreSQLParser.FULL - 101)) | (1 << (PostgreSQLParser.ILIKE - 101)) | (1 << (PostgreSQLParser.INNER_P - 101)) | (1 << (PostgreSQLParser.IS - 101)) | (1 << (PostgreSQLParser.ISNULL - 101)) | (1 << (PostgreSQLParser.JOIN - 101)) | (1 << (PostgreSQLParser.LEFT - 101)) | (1 << (PostgreSQLParser.LIKE - 101)) | (1 << (PostgreSQLParser.NATURAL - 101)) | (1 << (PostgreSQLParser.NOTNULL - 101)) | (1 << (PostgreSQLParser.OUTER_P - 101)) | (1 << (PostgreSQLParser.OVER - 101)) | (1 << (PostgreSQLParser.OVERLAPS - 101)) | (1 << (PostgreSQLParser.RIGHT - 101)) | (1 << (PostgreSQLParser.SIMILAR - 101)) | (1 << (PostgreSQLParser.VERBOSE - 101)) | (1 << (PostgreSQLParser.ABORT_P - 101)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 101)) | (1 << (PostgreSQLParser.ACCESS - 101)) | (1 << (PostgreSQLParser.ACTION - 101)))) !== 0) || ((((_la - 133)) & ~0x1f) == 0 && ((1 << (_la - 133)) & ((1 << (PostgreSQLParser.ADD_P - 133)) | (1 << (PostgreSQLParser.ADMIN - 133)) | (1 << (PostgreSQLParser.AFTER - 133)) | (1 << (PostgreSQLParser.AGGREGATE - 133)) | (1 << (PostgreSQLParser.ALSO - 133)) | (1 << (PostgreSQLParser.ALTER - 133)) | (1 << (PostgreSQLParser.ALWAYS - 133)) | (1 << (PostgreSQLParser.ASSERTION - 133)) | (1 << (PostgreSQLParser.ASSIGNMENT - 133)) | (1 << (PostgreSQLParser.AT - 133)) | (1 << (PostgreSQLParser.ATTRIBUTE - 133)) | (1 << (PostgreSQLParser.BACKWARD - 133)) | (1 << (PostgreSQLParser.BEFORE - 133)) | (1 << (PostgreSQLParser.BEGIN_P - 133)) | (1 << (PostgreSQLParser.BY - 133)) | (1 << (PostgreSQLParser.CACHE - 133)) | (1 << (PostgreSQLParser.CALLED - 133)) | (1 << (PostgreSQLParser.CASCADE - 133)) | (1 << (PostgreSQLParser.CASCADED - 133)) | (1 << (PostgreSQLParser.CATALOG - 133)) | (1 << (PostgreSQLParser.CHAIN - 133)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 133)) | (1 << (PostgreSQLParser.CHECKPOINT - 133)) | (1 << (PostgreSQLParser.CLASS - 133)) | (1 << (PostgreSQLParser.CLOSE - 133)) | (1 << (PostgreSQLParser.CLUSTER - 133)) | (1 << (PostgreSQLParser.COMMENT - 133)) | (1 << (PostgreSQLParser.COMMENTS - 133)) | (1 << (PostgreSQLParser.COMMIT - 133)) | (1 << (PostgreSQLParser.COMMITTED - 133)) | (1 << (PostgreSQLParser.CONFIGURATION - 133)) | (1 << (PostgreSQLParser.CONNECTION - 133)))) !== 0) || ((((_la - 165)) & ~0x1f) == 0 && ((1 << (_la - 165)) & ((1 << (PostgreSQLParser.CONSTRAINTS - 165)) | (1 << (PostgreSQLParser.CONTENT_P - 165)) | (1 << (PostgreSQLParser.CONTINUE_P - 165)) | (1 << (PostgreSQLParser.CONVERSION_P - 165)) | (1 << (PostgreSQLParser.COPY - 165)) | (1 << (PostgreSQLParser.COST - 165)) | (1 << (PostgreSQLParser.CSV - 165)) | (1 << (PostgreSQLParser.CURSOR - 165)) | (1 << (PostgreSQLParser.CYCLE - 165)) | (1 << (PostgreSQLParser.DATA_P - 165)) | (1 << (PostgreSQLParser.DATABASE - 165)) | (1 << (PostgreSQLParser.DAY_P - 165)) | (1 << (PostgreSQLParser.DEALLOCATE - 165)) | (1 << (PostgreSQLParser.DECLARE - 165)) | (1 << (PostgreSQLParser.DEFAULTS - 165)) | (1 << (PostgreSQLParser.DEFERRED - 165)) | (1 << (PostgreSQLParser.DEFINER - 165)) | (1 << (PostgreSQLParser.DELETE_P - 165)) | (1 << (PostgreSQLParser.DELIMITER - 165)) | (1 << (PostgreSQLParser.DELIMITERS - 165)) | (1 << (PostgreSQLParser.DICTIONARY - 165)) | (1 << (PostgreSQLParser.DISABLE_P - 165)) | (1 << (PostgreSQLParser.DISCARD - 165)) | (1 << (PostgreSQLParser.DOCUMENT_P - 165)) | (1 << (PostgreSQLParser.DOMAIN_P - 165)) | (1 << (PostgreSQLParser.DOUBLE_P - 165)) | (1 << (PostgreSQLParser.DROP - 165)) | (1 << (PostgreSQLParser.EACH - 165)) | (1 << (PostgreSQLParser.ENABLE_P - 165)) | (1 << (PostgreSQLParser.ENCODING - 165)) | (1 << (PostgreSQLParser.ENCRYPTED - 165)) | (1 << (PostgreSQLParser.ENUM_P - 165)))) !== 0) || ((((_la - 197)) & ~0x1f) == 0 && ((1 << (_la - 197)) & ((1 << (PostgreSQLParser.ESCAPE - 197)) | (1 << (PostgreSQLParser.EVENT - 197)) | (1 << (PostgreSQLParser.EXCLUDE - 197)) | (1 << (PostgreSQLParser.EXCLUDING - 197)) | (1 << (PostgreSQLParser.EXCLUSIVE - 197)) | (1 << (PostgreSQLParser.EXECUTE - 197)) | (1 << (PostgreSQLParser.EXPLAIN - 197)) | (1 << (PostgreSQLParser.EXTENSION - 197)) | (1 << (PostgreSQLParser.EXTERNAL - 197)) | (1 << (PostgreSQLParser.FAMILY - 197)) | (1 << (PostgreSQLParser.FIRST_P - 197)) | (1 << (PostgreSQLParser.FOLLOWING - 197)) | (1 << (PostgreSQLParser.FORCE - 197)) | (1 << (PostgreSQLParser.FORWARD - 197)) | (1 << (PostgreSQLParser.FUNCTION - 197)) | (1 << (PostgreSQLParser.FUNCTIONS - 197)) | (1 << (PostgreSQLParser.GLOBAL - 197)) | (1 << (PostgreSQLParser.GRANTED - 197)) | (1 << (PostgreSQLParser.HANDLER - 197)) | (1 << (PostgreSQLParser.HEADER_P - 197)) | (1 << (PostgreSQLParser.HOLD - 197)) | (1 << (PostgreSQLParser.HOUR_P - 197)) | (1 << (PostgreSQLParser.IDENTITY_P - 197)) | (1 << (PostgreSQLParser.IF_P - 197)) | (1 << (PostgreSQLParser.IMMEDIATE - 197)) | (1 << (PostgreSQLParser.IMMUTABLE - 197)) | (1 << (PostgreSQLParser.IMPLICIT_P - 197)) | (1 << (PostgreSQLParser.INCLUDING - 197)) | (1 << (PostgreSQLParser.INCREMENT - 197)) | (1 << (PostgreSQLParser.INDEX - 197)) | (1 << (PostgreSQLParser.INDEXES - 197)) | (1 << (PostgreSQLParser.INHERIT - 197)))) !== 0) || ((((_la - 229)) & ~0x1f) == 0 && ((1 << (_la - 229)) & ((1 << (PostgreSQLParser.INHERITS - 229)) | (1 << (PostgreSQLParser.INLINE_P - 229)) | (1 << (PostgreSQLParser.INSENSITIVE - 229)) | (1 << (PostgreSQLParser.INSERT - 229)) | (1 << (PostgreSQLParser.INSTEAD - 229)) | (1 << (PostgreSQLParser.INVOKER - 229)) | (1 << (PostgreSQLParser.ISOLATION - 229)) | (1 << (PostgreSQLParser.KEY - 229)) | (1 << (PostgreSQLParser.LABEL - 229)) | (1 << (PostgreSQLParser.LANGUAGE - 229)) | (1 << (PostgreSQLParser.LARGE_P - 229)) | (1 << (PostgreSQLParser.LAST_P - 229)) | (1 << (PostgreSQLParser.LEAKPROOF - 229)) | (1 << (PostgreSQLParser.LEVEL - 229)) | (1 << (PostgreSQLParser.LISTEN - 229)) | (1 << (PostgreSQLParser.LOAD - 229)) | (1 << (PostgreSQLParser.LOCAL - 229)) | (1 << (PostgreSQLParser.LOCATION - 229)) | (1 << (PostgreSQLParser.LOCK_P - 229)) | (1 << (PostgreSQLParser.MAPPING - 229)) | (1 << (PostgreSQLParser.MATCH - 229)) | (1 << (PostgreSQLParser.MATERIALIZED - 229)) | (1 << (PostgreSQLParser.MAXVALUE - 229)) | (1 << (PostgreSQLParser.MINUTE_P - 229)) | (1 << (PostgreSQLParser.MINVALUE - 229)) | (1 << (PostgreSQLParser.MODE - 229)) | (1 << (PostgreSQLParser.MONTH_P - 229)) | (1 << (PostgreSQLParser.MOVE - 229)) | (1 << (PostgreSQLParser.NAME_P - 229)) | (1 << (PostgreSQLParser.NAMES - 229)) | (1 << (PostgreSQLParser.NEXT - 229)) | (1 << (PostgreSQLParser.NO - 229)))) !== 0) || ((((_la - 261)) & ~0x1f) == 0 && ((1 << (_la - 261)) & ((1 << (PostgreSQLParser.NOTHING - 261)) | (1 << (PostgreSQLParser.NOTIFY - 261)) | (1 << (PostgreSQLParser.NOWAIT - 261)) | (1 << (PostgreSQLParser.NULLS_P - 261)) | (1 << (PostgreSQLParser.OBJECT_P - 261)) | (1 << (PostgreSQLParser.OF - 261)) | (1 << (PostgreSQLParser.OFF - 261)) | (1 << (PostgreSQLParser.OIDS - 261)) | (1 << (PostgreSQLParser.OPERATOR - 261)) | (1 << (PostgreSQLParser.OPTION - 261)) | (1 << (PostgreSQLParser.OPTIONS - 261)) | (1 << (PostgreSQLParser.OWNED - 261)) | (1 << (PostgreSQLParser.OWNER - 261)) | (1 << (PostgreSQLParser.PARSER - 261)) | (1 << (PostgreSQLParser.PARTIAL - 261)) | (1 << (PostgreSQLParser.PARTITION - 261)) | (1 << (PostgreSQLParser.PASSING - 261)) | (1 << (PostgreSQLParser.PASSWORD - 261)) | (1 << (PostgreSQLParser.PLANS - 261)) | (1 << (PostgreSQLParser.PRECEDING - 261)) | (1 << (PostgreSQLParser.PREPARE - 261)) | (1 << (PostgreSQLParser.PREPARED - 261)) | (1 << (PostgreSQLParser.PRESERVE - 261)) | (1 << (PostgreSQLParser.PRIOR - 261)) | (1 << (PostgreSQLParser.PRIVILEGES - 261)) | (1 << (PostgreSQLParser.PROCEDURAL - 261)) | (1 << (PostgreSQLParser.PROCEDURE - 261)) | (1 << (PostgreSQLParser.PROGRAM - 261)) | (1 << (PostgreSQLParser.QUOTE - 261)) | (1 << (PostgreSQLParser.RANGE - 261)) | (1 << (PostgreSQLParser.READ - 261)) | (1 << (PostgreSQLParser.REASSIGN - 261)))) !== 0) || ((((_la - 293)) & ~0x1f) == 0 && ((1 << (_la - 293)) & ((1 << (PostgreSQLParser.RECHECK - 293)) | (1 << (PostgreSQLParser.RECURSIVE - 293)) | (1 << (PostgreSQLParser.REF - 293)) | (1 << (PostgreSQLParser.REFRESH - 293)) | (1 << (PostgreSQLParser.REINDEX - 293)) | (1 << (PostgreSQLParser.RELATIVE_P - 293)) | (1 << (PostgreSQLParser.RELEASE - 293)) | (1 << (PostgreSQLParser.RENAME - 293)) | (1 << (PostgreSQLParser.REPEATABLE - 293)) | (1 << (PostgreSQLParser.REPLACE - 293)) | (1 << (PostgreSQLParser.REPLICA - 293)) | (1 << (PostgreSQLParser.RESET - 293)) | (1 << (PostgreSQLParser.RESTART - 293)) | (1 << (PostgreSQLParser.RESTRICT - 293)) | (1 << (PostgreSQLParser.RETURNS - 293)) | (1 << (PostgreSQLParser.REVOKE - 293)) | (1 << (PostgreSQLParser.ROLE - 293)) | (1 << (PostgreSQLParser.ROLLBACK - 293)) | (1 << (PostgreSQLParser.ROWS - 293)) | (1 << (PostgreSQLParser.RULE - 293)) | (1 << (PostgreSQLParser.SAVEPOINT - 293)) | (1 << (PostgreSQLParser.SCHEMA - 293)) | (1 << (PostgreSQLParser.SCROLL - 293)) | (1 << (PostgreSQLParser.SEARCH - 293)) | (1 << (PostgreSQLParser.SECOND_P - 293)) | (1 << (PostgreSQLParser.SECURITY - 293)) | (1 << (PostgreSQLParser.SEQUENCE - 293)) | (1 << (PostgreSQLParser.SEQUENCES - 293)) | (1 << (PostgreSQLParser.SERIALIZABLE - 293)) | (1 << (PostgreSQLParser.SERVER - 293)) | (1 << (PostgreSQLParser.SESSION - 293)) | (1 << (PostgreSQLParser.SET - 293)))) !== 0) || ((((_la - 325)) & ~0x1f) == 0 && ((1 << (_la - 325)) & ((1 << (PostgreSQLParser.SHARE - 325)) | (1 << (PostgreSQLParser.SHOW - 325)) | (1 << (PostgreSQLParser.SIMPLE - 325)) | (1 << (PostgreSQLParser.SNAPSHOT - 325)) | (1 << (PostgreSQLParser.STABLE - 325)) | (1 << (PostgreSQLParser.STANDALONE_P - 325)) | (1 << (PostgreSQLParser.START - 325)) | (1 << (PostgreSQLParser.STATEMENT - 325)) | (1 << (PostgreSQLParser.STATISTICS - 325)) | (1 << (PostgreSQLParser.STDIN - 325)) | (1 << (PostgreSQLParser.STDOUT - 325)) | (1 << (PostgreSQLParser.STORAGE - 325)) | (1 << (PostgreSQLParser.STRICT_P - 325)) | (1 << (PostgreSQLParser.STRIP_P - 325)) | (1 << (PostgreSQLParser.SYSID - 325)) | (1 << (PostgreSQLParser.SYSTEM_P - 325)) | (1 << (PostgreSQLParser.TABLES - 325)) | (1 << (PostgreSQLParser.TABLESPACE - 325)) | (1 << (PostgreSQLParser.TEMP - 325)) | (1 << (PostgreSQLParser.TEMPLATE - 325)) | (1 << (PostgreSQLParser.TEMPORARY - 325)) | (1 << (PostgreSQLParser.TEXT_P - 325)) | (1 << (PostgreSQLParser.TRANSACTION - 325)) | (1 << (PostgreSQLParser.TRIGGER - 325)) | (1 << (PostgreSQLParser.TRUNCATE - 325)) | (1 << (PostgreSQLParser.TRUSTED - 325)) | (1 << (PostgreSQLParser.TYPE_P - 325)) | (1 << (PostgreSQLParser.TYPES_P - 325)) | (1 << (PostgreSQLParser.UNBOUNDED - 325)) | (1 << (PostgreSQLParser.UNCOMMITTED - 325)) | (1 << (PostgreSQLParser.UNENCRYPTED - 325)) | (1 << (PostgreSQLParser.UNKNOWN - 325)))) !== 0) || ((((_la - 357)) & ~0x1f) == 0 && ((1 << (_la - 357)) & ((1 << (PostgreSQLParser.UNLISTEN - 357)) | (1 << (PostgreSQLParser.UNLOGGED - 357)) | (1 << (PostgreSQLParser.UNTIL - 357)) | (1 << (PostgreSQLParser.UPDATE - 357)) | (1 << (PostgreSQLParser.VACUUM - 357)) | (1 << (PostgreSQLParser.VALID - 357)) | (1 << (PostgreSQLParser.VALIDATE - 357)) | (1 << (PostgreSQLParser.VALIDATOR - 357)) | (1 << (PostgreSQLParser.VARYING - 357)) | (1 << (PostgreSQLParser.VERSION_P - 357)) | (1 << (PostgreSQLParser.VIEW - 357)) | (1 << (PostgreSQLParser.VOLATILE - 357)) | (1 << (PostgreSQLParser.WHITESPACE_P - 357)) | (1 << (PostgreSQLParser.WITHOUT - 357)) | (1 << (PostgreSQLParser.WORK - 357)) | (1 << (PostgreSQLParser.WRAPPER - 357)) | (1 << (PostgreSQLParser.WRITE - 357)) | (1 << (PostgreSQLParser.XML_P - 357)) | (1 << (PostgreSQLParser.YEAR_P - 357)) | (1 << (PostgreSQLParser.YES_P - 357)) | (1 << (PostgreSQLParser.ZONE - 357)) | (1 << (PostgreSQLParser.BETWEEN - 357)) | (1 << (PostgreSQLParser.BIGINT - 357)) | (1 << (PostgreSQLParser.BIT - 357)) | (1 << (PostgreSQLParser.BOOLEAN_P - 357)) | (1 << (PostgreSQLParser.CHAR_P - 357)) | (1 << (PostgreSQLParser.CHARACTER - 357)) | (1 << (PostgreSQLParser.COALESCE - 357)) | (1 << (PostgreSQLParser.DEC - 357)) | (1 << (PostgreSQLParser.DECIMAL_P - 357)) | (1 << (PostgreSQLParser.EXISTS - 357)) | (1 << (PostgreSQLParser.EXTRACT - 357)))) !== 0) || ((((_la - 389)) & ~0x1f) == 0 && ((1 << (_la - 389)) & ((1 << (PostgreSQLParser.FLOAT_P - 389)) | (1 << (PostgreSQLParser.GREATEST - 389)) | (1 << (PostgreSQLParser.INOUT - 389)) | (1 << (PostgreSQLParser.INT_P - 389)) | (1 << (PostgreSQLParser.INTEGER - 389)) | (1 << (PostgreSQLParser.INTERVAL - 389)) | (1 << (PostgreSQLParser.LEAST - 389)) | (1 << (PostgreSQLParser.NATIONAL - 389)) | (1 << (PostgreSQLParser.NCHAR - 389)) | (1 << (PostgreSQLParser.NONE - 389)) | (1 << (PostgreSQLParser.NULLIF - 389)) | (1 << (PostgreSQLParser.NUMERIC - 389)) | (1 << (PostgreSQLParser.OVERLAY - 389)) | (1 << (PostgreSQLParser.POSITION - 389)) | (1 << (PostgreSQLParser.PRECISION - 389)) | (1 << (PostgreSQLParser.REAL - 389)) | (1 << (PostgreSQLParser.ROW - 389)) | (1 << (PostgreSQLParser.SETOF - 389)) | (1 << (PostgreSQLParser.SMALLINT - 389)) | (1 << (PostgreSQLParser.SUBSTRING - 389)) | (1 << (PostgreSQLParser.TIME - 389)) | (1 << (PostgreSQLParser.TIMESTAMP - 389)) | (1 << (PostgreSQLParser.TREAT - 389)) | (1 << (PostgreSQLParser.TRIM - 389)) | (1 << (PostgreSQLParser.VALUES - 389)) | (1 << (PostgreSQLParser.VARCHAR - 389)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 389)) | (1 << (PostgreSQLParser.XMLCONCAT - 389)) | (1 << (PostgreSQLParser.XMLELEMENT - 389)) | (1 << (PostgreSQLParser.XMLEXISTS - 389)) | (1 << (PostgreSQLParser.XMLFOREST - 389)) | (1 << (PostgreSQLParser.XMLPARSE - 389)))) !== 0) || ((((_la - 421)) & ~0x1f) == 0 && ((1 << (_la - 421)) & ((1 << (PostgreSQLParser.XMLPI - 421)) | (1 << (PostgreSQLParser.XMLROOT - 421)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 421)) | (1 << (PostgreSQLParser.CALL - 421)) | (1 << (PostgreSQLParser.CURRENT_P - 421)) | (1 << (PostgreSQLParser.ATTACH - 421)) | (1 << (PostgreSQLParser.DETACH - 421)) | (1 << (PostgreSQLParser.EXPRESSION - 421)) | (1 << (PostgreSQLParser.GENERATED - 421)) | (1 << (PostgreSQLParser.LOGGED - 421)) | (1 << (PostgreSQLParser.STORED - 421)) | (1 << (PostgreSQLParser.INCLUDE - 421)) | (1 << (PostgreSQLParser.ROUTINE - 421)) | (1 << (PostgreSQLParser.TRANSFORM - 421)) | (1 << (PostgreSQLParser.IMPORT_P - 421)) | (1 << (PostgreSQLParser.POLICY - 421)) | (1 << (PostgreSQLParser.METHOD - 421)) | (1 << (PostgreSQLParser.REFERENCING - 421)) | (1 << (PostgreSQLParser.NEW - 421)) | (1 << (PostgreSQLParser.OLD - 421)) | (1 << (PostgreSQLParser.VALUE_P - 421)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 421)) | (1 << (PostgreSQLParser.PUBLICATION - 421)) | (1 << (PostgreSQLParser.OUT_P - 421)) | (1 << (PostgreSQLParser.ROUTINES - 421)) | (1 << (PostgreSQLParser.SCHEMAS - 421)) | (1 << (PostgreSQLParser.PROCEDURES - 421)) | (1 << (PostgreSQLParser.INPUT_P - 421)) | (1 << (PostgreSQLParser.SUPPORT - 421)) | (1 << (PostgreSQLParser.PARALLEL - 421)) | (1 << (PostgreSQLParser.SQL_P - 421)))) !== 0) || ((((_la - 453)) & ~0x1f) == 0 && ((1 << (_la - 453)) & ((1 << (PostgreSQLParser.DEPENDS - 453)) | (1 << (PostgreSQLParser.OVERRIDING - 453)) | (1 << (PostgreSQLParser.CONFLICT - 453)) | (1 << (PostgreSQLParser.SKIP_P - 453)) | (1 << (PostgreSQLParser.LOCKED - 453)) | (1 << (PostgreSQLParser.TIES - 453)) | (1 << (PostgreSQLParser.ROLLUP - 453)) | (1 << (PostgreSQLParser.CUBE - 453)) | (1 << (PostgreSQLParser.GROUPING - 453)) | (1 << (PostgreSQLParser.SETS - 453)) | (1 << (PostgreSQLParser.TABLESAMPLE - 453)) | (1 << (PostgreSQLParser.ORDINALITY - 453)) | (1 << (PostgreSQLParser.XMLTABLE - 453)) | (1 << (PostgreSQLParser.COLUMNS - 453)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 453)) | (1 << (PostgreSQLParser.ROWTYPE - 453)) | (1 << (PostgreSQLParser.NORMALIZED - 453)) | (1 << (PostgreSQLParser.WITHIN - 453)) | (1 << (PostgreSQLParser.FILTER - 453)) | (1 << (PostgreSQLParser.GROUPS - 453)) | (1 << (PostgreSQLParser.OTHERS - 453)) | (1 << (PostgreSQLParser.NFC - 453)) | (1 << (PostgreSQLParser.NFD - 453)) | (1 << (PostgreSQLParser.NFKC - 453)) | (1 << (PostgreSQLParser.NFKD - 453)) | (1 << (PostgreSQLParser.UESCAPE - 453)) | (1 << (PostgreSQLParser.VIEWS - 453)) | (1 << (PostgreSQLParser.NORMALIZE - 453)) | (1 << (PostgreSQLParser.DUMP - 453)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 453)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 453)) | (1 << (PostgreSQLParser.ERROR - 453)))) !== 0) || ((((_la - 485)) & ~0x1f) == 0 && ((1 << (_la - 485)) & ((1 << (PostgreSQLParser.USE_VARIABLE - 485)) | (1 << (PostgreSQLParser.USE_COLUMN - 485)) | (1 << (PostgreSQLParser.ALIAS - 485)) | (1 << (PostgreSQLParser.CONSTANT - 485)) | (1 << (PostgreSQLParser.PERFORM - 485)) | (1 << (PostgreSQLParser.GET - 485)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 485)) | (1 << (PostgreSQLParser.STACKED - 485)) | (1 << (PostgreSQLParser.ELSIF - 485)) | (1 << (PostgreSQLParser.REVERSE - 485)) | (1 << (PostgreSQLParser.SLICE - 485)) | (1 << (PostgreSQLParser.EXIT - 485)) | (1 << (PostgreSQLParser.RETURN - 485)) | (1 << (PostgreSQLParser.QUERY - 485)) | (1 << (PostgreSQLParser.RAISE - 485)) | (1 << (PostgreSQLParser.SQLSTATE - 485)) | (1 << (PostgreSQLParser.DEBUG - 485)) | (1 << (PostgreSQLParser.LOG - 485)) | (1 << (PostgreSQLParser.INFO - 485)) | (1 << (PostgreSQLParser.NOTICE - 485)) | (1 << (PostgreSQLParser.WARNING - 485)) | (1 << (PostgreSQLParser.EXCEPTION - 485)) | (1 << (PostgreSQLParser.ASSERT - 485)) | (1 << (PostgreSQLParser.OPEN - 485)) | (1 << (PostgreSQLParser.Identifier - 485)) | (1 << (PostgreSQLParser.QuotedIdentifier - 485)))) !== 0) || ((((_la - 517)) & ~0x1f) == 0 && ((1 << (_la - 517)) & ((1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 517)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 517)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 517)))) !== 0)) { + this.state = 5370; + this.func_args_list(); + } + + this.state = 5373; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_args_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_args_list; + return this; +} + +Func_args_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_args_listContext.prototype.constructor = Func_args_listContext; + +Func_args_listContext.prototype.func_arg = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Func_argContext); + } else { + return this.getTypedRuleContext(Func_argContext,i); + } +}; + +Func_args_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Func_args_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_args_list(this); + } +}; + +Func_args_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_args_list(this); + } +}; + +Func_args_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_args_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_args_listContext = Func_args_listContext; + +PostgreSQLParser.prototype.func_args_list = function() { + + var localctx = new Func_args_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 622, PostgreSQLParser.RULE_func_args_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5375; + this.func_arg(); + this.state = 5380; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5376; + this.match(PostgreSQLParser.COMMA); + this.state = 5377; + this.func_arg(); + this.state = 5382; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Function_with_argtypes_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_function_with_argtypes_list; + return this; +} + +Function_with_argtypes_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Function_with_argtypes_listContext.prototype.constructor = Function_with_argtypes_listContext; + +Function_with_argtypes_listContext.prototype.function_with_argtypes = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Function_with_argtypesContext); + } else { + return this.getTypedRuleContext(Function_with_argtypesContext,i); + } +}; + +Function_with_argtypes_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Function_with_argtypes_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunction_with_argtypes_list(this); + } +}; + +Function_with_argtypes_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunction_with_argtypes_list(this); + } +}; + +Function_with_argtypes_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunction_with_argtypes_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Function_with_argtypes_listContext = Function_with_argtypes_listContext; + +PostgreSQLParser.prototype.function_with_argtypes_list = function() { + + var localctx = new Function_with_argtypes_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 624, PostgreSQLParser.RULE_function_with_argtypes_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5383; + this.function_with_argtypes(); + this.state = 5388; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5384; + this.match(PostgreSQLParser.COMMA); + this.state = 5385; + this.function_with_argtypes(); + this.state = 5390; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Function_with_argtypesContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_function_with_argtypes; + return this; +} + +Function_with_argtypesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Function_with_argtypesContext.prototype.constructor = Function_with_argtypesContext; + +Function_with_argtypesContext.prototype.func_name = function() { + return this.getTypedRuleContext(Func_nameContext,0); +}; + +Function_with_argtypesContext.prototype.func_args = function() { + return this.getTypedRuleContext(Func_argsContext,0); +}; + +Function_with_argtypesContext.prototype.type_func_name_keyword = function() { + return this.getTypedRuleContext(Type_func_name_keywordContext,0); +}; + +Function_with_argtypesContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Function_with_argtypesContext.prototype.indirection = function() { + return this.getTypedRuleContext(IndirectionContext,0); +}; + +Function_with_argtypesContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunction_with_argtypes(this); + } +}; + +Function_with_argtypesContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunction_with_argtypes(this); + } +}; + +Function_with_argtypesContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunction_with_argtypes(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Function_with_argtypesContext = Function_with_argtypesContext; + +PostgreSQLParser.prototype.function_with_argtypes = function() { + + var localctx = new Function_with_argtypesContext(this, this._ctx, this.state); + this.enterRule(localctx, 626, PostgreSQLParser.RULE_function_with_argtypes); + var _la = 0; // Token type + try { + this.state = 5399; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,270,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5391; + this.func_name(); + this.state = 5392; + this.func_args(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5394; + this.type_func_name_keyword(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5395; + this.colid(); + this.state = 5397; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OPEN_BRACKET || _la===PostgreSQLParser.DOT) { + this.state = 5396; + this.indirection(); + } + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_args_with_defaultsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_args_with_defaults; + return this; +} + +Func_args_with_defaultsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_args_with_defaultsContext.prototype.constructor = Func_args_with_defaultsContext; + +Func_args_with_defaultsContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Func_args_with_defaultsContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Func_args_with_defaultsContext.prototype.func_args_with_defaults_list = function() { + return this.getTypedRuleContext(Func_args_with_defaults_listContext,0); +}; + +Func_args_with_defaultsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_args_with_defaults(this); + } +}; + +Func_args_with_defaultsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_args_with_defaults(this); + } +}; + +Func_args_with_defaultsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_args_with_defaults(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_args_with_defaultsContext = Func_args_with_defaultsContext; + +PostgreSQLParser.prototype.func_args_with_defaults = function() { + + var localctx = new Func_args_with_defaultsContext(this, this._ctx, this.state); + this.enterRule(localctx, 628, PostgreSQLParser.RULE_func_args_with_defaults); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5401; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5403; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(((((_la - 33)) & ~0x1f) == 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.AND - 33)) | (1 << (PostgreSQLParser.ARRAY - 33)) | (1 << (PostgreSQLParser.COLLATE - 33)) | (1 << (PostgreSQLParser.COLUMN - 33)) | (1 << (PostgreSQLParser.CONSTRAINT - 33)) | (1 << (PostgreSQLParser.DEFAULT - 33)) | (1 << (PostgreSQLParser.DO - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || _la===PostgreSQLParser.IN_P || _la===PostgreSQLParser.TABLE || ((((_la - 101)) & ~0x1f) == 0 && ((1 << (_la - 101)) & ((1 << (PostgreSQLParser.VARIADIC - 101)) | (1 << (PostgreSQLParser.AUTHORIZATION - 101)) | (1 << (PostgreSQLParser.BINARY - 101)) | (1 << (PostgreSQLParser.COLLATION - 101)) | (1 << (PostgreSQLParser.CONCURRENTLY - 101)) | (1 << (PostgreSQLParser.CROSS - 101)) | (1 << (PostgreSQLParser.CURRENT_SCHEMA - 101)) | (1 << (PostgreSQLParser.FREEZE - 101)) | (1 << (PostgreSQLParser.FULL - 101)) | (1 << (PostgreSQLParser.ILIKE - 101)) | (1 << (PostgreSQLParser.INNER_P - 101)) | (1 << (PostgreSQLParser.IS - 101)) | (1 << (PostgreSQLParser.ISNULL - 101)) | (1 << (PostgreSQLParser.JOIN - 101)) | (1 << (PostgreSQLParser.LEFT - 101)) | (1 << (PostgreSQLParser.LIKE - 101)) | (1 << (PostgreSQLParser.NATURAL - 101)) | (1 << (PostgreSQLParser.NOTNULL - 101)) | (1 << (PostgreSQLParser.OUTER_P - 101)) | (1 << (PostgreSQLParser.OVER - 101)) | (1 << (PostgreSQLParser.OVERLAPS - 101)) | (1 << (PostgreSQLParser.RIGHT - 101)) | (1 << (PostgreSQLParser.SIMILAR - 101)) | (1 << (PostgreSQLParser.VERBOSE - 101)) | (1 << (PostgreSQLParser.ABORT_P - 101)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 101)) | (1 << (PostgreSQLParser.ACCESS - 101)) | (1 << (PostgreSQLParser.ACTION - 101)))) !== 0) || ((((_la - 133)) & ~0x1f) == 0 && ((1 << (_la - 133)) & ((1 << (PostgreSQLParser.ADD_P - 133)) | (1 << (PostgreSQLParser.ADMIN - 133)) | (1 << (PostgreSQLParser.AFTER - 133)) | (1 << (PostgreSQLParser.AGGREGATE - 133)) | (1 << (PostgreSQLParser.ALSO - 133)) | (1 << (PostgreSQLParser.ALTER - 133)) | (1 << (PostgreSQLParser.ALWAYS - 133)) | (1 << (PostgreSQLParser.ASSERTION - 133)) | (1 << (PostgreSQLParser.ASSIGNMENT - 133)) | (1 << (PostgreSQLParser.AT - 133)) | (1 << (PostgreSQLParser.ATTRIBUTE - 133)) | (1 << (PostgreSQLParser.BACKWARD - 133)) | (1 << (PostgreSQLParser.BEFORE - 133)) | (1 << (PostgreSQLParser.BEGIN_P - 133)) | (1 << (PostgreSQLParser.BY - 133)) | (1 << (PostgreSQLParser.CACHE - 133)) | (1 << (PostgreSQLParser.CALLED - 133)) | (1 << (PostgreSQLParser.CASCADE - 133)) | (1 << (PostgreSQLParser.CASCADED - 133)) | (1 << (PostgreSQLParser.CATALOG - 133)) | (1 << (PostgreSQLParser.CHAIN - 133)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 133)) | (1 << (PostgreSQLParser.CHECKPOINT - 133)) | (1 << (PostgreSQLParser.CLASS - 133)) | (1 << (PostgreSQLParser.CLOSE - 133)) | (1 << (PostgreSQLParser.CLUSTER - 133)) | (1 << (PostgreSQLParser.COMMENT - 133)) | (1 << (PostgreSQLParser.COMMENTS - 133)) | (1 << (PostgreSQLParser.COMMIT - 133)) | (1 << (PostgreSQLParser.COMMITTED - 133)) | (1 << (PostgreSQLParser.CONFIGURATION - 133)) | (1 << (PostgreSQLParser.CONNECTION - 133)))) !== 0) || ((((_la - 165)) & ~0x1f) == 0 && ((1 << (_la - 165)) & ((1 << (PostgreSQLParser.CONSTRAINTS - 165)) | (1 << (PostgreSQLParser.CONTENT_P - 165)) | (1 << (PostgreSQLParser.CONTINUE_P - 165)) | (1 << (PostgreSQLParser.CONVERSION_P - 165)) | (1 << (PostgreSQLParser.COPY - 165)) | (1 << (PostgreSQLParser.COST - 165)) | (1 << (PostgreSQLParser.CSV - 165)) | (1 << (PostgreSQLParser.CURSOR - 165)) | (1 << (PostgreSQLParser.CYCLE - 165)) | (1 << (PostgreSQLParser.DATA_P - 165)) | (1 << (PostgreSQLParser.DATABASE - 165)) | (1 << (PostgreSQLParser.DAY_P - 165)) | (1 << (PostgreSQLParser.DEALLOCATE - 165)) | (1 << (PostgreSQLParser.DECLARE - 165)) | (1 << (PostgreSQLParser.DEFAULTS - 165)) | (1 << (PostgreSQLParser.DEFERRED - 165)) | (1 << (PostgreSQLParser.DEFINER - 165)) | (1 << (PostgreSQLParser.DELETE_P - 165)) | (1 << (PostgreSQLParser.DELIMITER - 165)) | (1 << (PostgreSQLParser.DELIMITERS - 165)) | (1 << (PostgreSQLParser.DICTIONARY - 165)) | (1 << (PostgreSQLParser.DISABLE_P - 165)) | (1 << (PostgreSQLParser.DISCARD - 165)) | (1 << (PostgreSQLParser.DOCUMENT_P - 165)) | (1 << (PostgreSQLParser.DOMAIN_P - 165)) | (1 << (PostgreSQLParser.DOUBLE_P - 165)) | (1 << (PostgreSQLParser.DROP - 165)) | (1 << (PostgreSQLParser.EACH - 165)) | (1 << (PostgreSQLParser.ENABLE_P - 165)) | (1 << (PostgreSQLParser.ENCODING - 165)) | (1 << (PostgreSQLParser.ENCRYPTED - 165)) | (1 << (PostgreSQLParser.ENUM_P - 165)))) !== 0) || ((((_la - 197)) & ~0x1f) == 0 && ((1 << (_la - 197)) & ((1 << (PostgreSQLParser.ESCAPE - 197)) | (1 << (PostgreSQLParser.EVENT - 197)) | (1 << (PostgreSQLParser.EXCLUDE - 197)) | (1 << (PostgreSQLParser.EXCLUDING - 197)) | (1 << (PostgreSQLParser.EXCLUSIVE - 197)) | (1 << (PostgreSQLParser.EXECUTE - 197)) | (1 << (PostgreSQLParser.EXPLAIN - 197)) | (1 << (PostgreSQLParser.EXTENSION - 197)) | (1 << (PostgreSQLParser.EXTERNAL - 197)) | (1 << (PostgreSQLParser.FAMILY - 197)) | (1 << (PostgreSQLParser.FIRST_P - 197)) | (1 << (PostgreSQLParser.FOLLOWING - 197)) | (1 << (PostgreSQLParser.FORCE - 197)) | (1 << (PostgreSQLParser.FORWARD - 197)) | (1 << (PostgreSQLParser.FUNCTION - 197)) | (1 << (PostgreSQLParser.FUNCTIONS - 197)) | (1 << (PostgreSQLParser.GLOBAL - 197)) | (1 << (PostgreSQLParser.GRANTED - 197)) | (1 << (PostgreSQLParser.HANDLER - 197)) | (1 << (PostgreSQLParser.HEADER_P - 197)) | (1 << (PostgreSQLParser.HOLD - 197)) | (1 << (PostgreSQLParser.HOUR_P - 197)) | (1 << (PostgreSQLParser.IDENTITY_P - 197)) | (1 << (PostgreSQLParser.IF_P - 197)) | (1 << (PostgreSQLParser.IMMEDIATE - 197)) | (1 << (PostgreSQLParser.IMMUTABLE - 197)) | (1 << (PostgreSQLParser.IMPLICIT_P - 197)) | (1 << (PostgreSQLParser.INCLUDING - 197)) | (1 << (PostgreSQLParser.INCREMENT - 197)) | (1 << (PostgreSQLParser.INDEX - 197)) | (1 << (PostgreSQLParser.INDEXES - 197)) | (1 << (PostgreSQLParser.INHERIT - 197)))) !== 0) || ((((_la - 229)) & ~0x1f) == 0 && ((1 << (_la - 229)) & ((1 << (PostgreSQLParser.INHERITS - 229)) | (1 << (PostgreSQLParser.INLINE_P - 229)) | (1 << (PostgreSQLParser.INSENSITIVE - 229)) | (1 << (PostgreSQLParser.INSERT - 229)) | (1 << (PostgreSQLParser.INSTEAD - 229)) | (1 << (PostgreSQLParser.INVOKER - 229)) | (1 << (PostgreSQLParser.ISOLATION - 229)) | (1 << (PostgreSQLParser.KEY - 229)) | (1 << (PostgreSQLParser.LABEL - 229)) | (1 << (PostgreSQLParser.LANGUAGE - 229)) | (1 << (PostgreSQLParser.LARGE_P - 229)) | (1 << (PostgreSQLParser.LAST_P - 229)) | (1 << (PostgreSQLParser.LEAKPROOF - 229)) | (1 << (PostgreSQLParser.LEVEL - 229)) | (1 << (PostgreSQLParser.LISTEN - 229)) | (1 << (PostgreSQLParser.LOAD - 229)) | (1 << (PostgreSQLParser.LOCAL - 229)) | (1 << (PostgreSQLParser.LOCATION - 229)) | (1 << (PostgreSQLParser.LOCK_P - 229)) | (1 << (PostgreSQLParser.MAPPING - 229)) | (1 << (PostgreSQLParser.MATCH - 229)) | (1 << (PostgreSQLParser.MATERIALIZED - 229)) | (1 << (PostgreSQLParser.MAXVALUE - 229)) | (1 << (PostgreSQLParser.MINUTE_P - 229)) | (1 << (PostgreSQLParser.MINVALUE - 229)) | (1 << (PostgreSQLParser.MODE - 229)) | (1 << (PostgreSQLParser.MONTH_P - 229)) | (1 << (PostgreSQLParser.MOVE - 229)) | (1 << (PostgreSQLParser.NAME_P - 229)) | (1 << (PostgreSQLParser.NAMES - 229)) | (1 << (PostgreSQLParser.NEXT - 229)) | (1 << (PostgreSQLParser.NO - 229)))) !== 0) || ((((_la - 261)) & ~0x1f) == 0 && ((1 << (_la - 261)) & ((1 << (PostgreSQLParser.NOTHING - 261)) | (1 << (PostgreSQLParser.NOTIFY - 261)) | (1 << (PostgreSQLParser.NOWAIT - 261)) | (1 << (PostgreSQLParser.NULLS_P - 261)) | (1 << (PostgreSQLParser.OBJECT_P - 261)) | (1 << (PostgreSQLParser.OF - 261)) | (1 << (PostgreSQLParser.OFF - 261)) | (1 << (PostgreSQLParser.OIDS - 261)) | (1 << (PostgreSQLParser.OPERATOR - 261)) | (1 << (PostgreSQLParser.OPTION - 261)) | (1 << (PostgreSQLParser.OPTIONS - 261)) | (1 << (PostgreSQLParser.OWNED - 261)) | (1 << (PostgreSQLParser.OWNER - 261)) | (1 << (PostgreSQLParser.PARSER - 261)) | (1 << (PostgreSQLParser.PARTIAL - 261)) | (1 << (PostgreSQLParser.PARTITION - 261)) | (1 << (PostgreSQLParser.PASSING - 261)) | (1 << (PostgreSQLParser.PASSWORD - 261)) | (1 << (PostgreSQLParser.PLANS - 261)) | (1 << (PostgreSQLParser.PRECEDING - 261)) | (1 << (PostgreSQLParser.PREPARE - 261)) | (1 << (PostgreSQLParser.PREPARED - 261)) | (1 << (PostgreSQLParser.PRESERVE - 261)) | (1 << (PostgreSQLParser.PRIOR - 261)) | (1 << (PostgreSQLParser.PRIVILEGES - 261)) | (1 << (PostgreSQLParser.PROCEDURAL - 261)) | (1 << (PostgreSQLParser.PROCEDURE - 261)) | (1 << (PostgreSQLParser.PROGRAM - 261)) | (1 << (PostgreSQLParser.QUOTE - 261)) | (1 << (PostgreSQLParser.RANGE - 261)) | (1 << (PostgreSQLParser.READ - 261)) | (1 << (PostgreSQLParser.REASSIGN - 261)))) !== 0) || ((((_la - 293)) & ~0x1f) == 0 && ((1 << (_la - 293)) & ((1 << (PostgreSQLParser.RECHECK - 293)) | (1 << (PostgreSQLParser.RECURSIVE - 293)) | (1 << (PostgreSQLParser.REF - 293)) | (1 << (PostgreSQLParser.REFRESH - 293)) | (1 << (PostgreSQLParser.REINDEX - 293)) | (1 << (PostgreSQLParser.RELATIVE_P - 293)) | (1 << (PostgreSQLParser.RELEASE - 293)) | (1 << (PostgreSQLParser.RENAME - 293)) | (1 << (PostgreSQLParser.REPEATABLE - 293)) | (1 << (PostgreSQLParser.REPLACE - 293)) | (1 << (PostgreSQLParser.REPLICA - 293)) | (1 << (PostgreSQLParser.RESET - 293)) | (1 << (PostgreSQLParser.RESTART - 293)) | (1 << (PostgreSQLParser.RESTRICT - 293)) | (1 << (PostgreSQLParser.RETURNS - 293)) | (1 << (PostgreSQLParser.REVOKE - 293)) | (1 << (PostgreSQLParser.ROLE - 293)) | (1 << (PostgreSQLParser.ROLLBACK - 293)) | (1 << (PostgreSQLParser.ROWS - 293)) | (1 << (PostgreSQLParser.RULE - 293)) | (1 << (PostgreSQLParser.SAVEPOINT - 293)) | (1 << (PostgreSQLParser.SCHEMA - 293)) | (1 << (PostgreSQLParser.SCROLL - 293)) | (1 << (PostgreSQLParser.SEARCH - 293)) | (1 << (PostgreSQLParser.SECOND_P - 293)) | (1 << (PostgreSQLParser.SECURITY - 293)) | (1 << (PostgreSQLParser.SEQUENCE - 293)) | (1 << (PostgreSQLParser.SEQUENCES - 293)) | (1 << (PostgreSQLParser.SERIALIZABLE - 293)) | (1 << (PostgreSQLParser.SERVER - 293)) | (1 << (PostgreSQLParser.SESSION - 293)) | (1 << (PostgreSQLParser.SET - 293)))) !== 0) || ((((_la - 325)) & ~0x1f) == 0 && ((1 << (_la - 325)) & ((1 << (PostgreSQLParser.SHARE - 325)) | (1 << (PostgreSQLParser.SHOW - 325)) | (1 << (PostgreSQLParser.SIMPLE - 325)) | (1 << (PostgreSQLParser.SNAPSHOT - 325)) | (1 << (PostgreSQLParser.STABLE - 325)) | (1 << (PostgreSQLParser.STANDALONE_P - 325)) | (1 << (PostgreSQLParser.START - 325)) | (1 << (PostgreSQLParser.STATEMENT - 325)) | (1 << (PostgreSQLParser.STATISTICS - 325)) | (1 << (PostgreSQLParser.STDIN - 325)) | (1 << (PostgreSQLParser.STDOUT - 325)) | (1 << (PostgreSQLParser.STORAGE - 325)) | (1 << (PostgreSQLParser.STRICT_P - 325)) | (1 << (PostgreSQLParser.STRIP_P - 325)) | (1 << (PostgreSQLParser.SYSID - 325)) | (1 << (PostgreSQLParser.SYSTEM_P - 325)) | (1 << (PostgreSQLParser.TABLES - 325)) | (1 << (PostgreSQLParser.TABLESPACE - 325)) | (1 << (PostgreSQLParser.TEMP - 325)) | (1 << (PostgreSQLParser.TEMPLATE - 325)) | (1 << (PostgreSQLParser.TEMPORARY - 325)) | (1 << (PostgreSQLParser.TEXT_P - 325)) | (1 << (PostgreSQLParser.TRANSACTION - 325)) | (1 << (PostgreSQLParser.TRIGGER - 325)) | (1 << (PostgreSQLParser.TRUNCATE - 325)) | (1 << (PostgreSQLParser.TRUSTED - 325)) | (1 << (PostgreSQLParser.TYPE_P - 325)) | (1 << (PostgreSQLParser.TYPES_P - 325)) | (1 << (PostgreSQLParser.UNBOUNDED - 325)) | (1 << (PostgreSQLParser.UNCOMMITTED - 325)) | (1 << (PostgreSQLParser.UNENCRYPTED - 325)) | (1 << (PostgreSQLParser.UNKNOWN - 325)))) !== 0) || ((((_la - 357)) & ~0x1f) == 0 && ((1 << (_la - 357)) & ((1 << (PostgreSQLParser.UNLISTEN - 357)) | (1 << (PostgreSQLParser.UNLOGGED - 357)) | (1 << (PostgreSQLParser.UNTIL - 357)) | (1 << (PostgreSQLParser.UPDATE - 357)) | (1 << (PostgreSQLParser.VACUUM - 357)) | (1 << (PostgreSQLParser.VALID - 357)) | (1 << (PostgreSQLParser.VALIDATE - 357)) | (1 << (PostgreSQLParser.VALIDATOR - 357)) | (1 << (PostgreSQLParser.VARYING - 357)) | (1 << (PostgreSQLParser.VERSION_P - 357)) | (1 << (PostgreSQLParser.VIEW - 357)) | (1 << (PostgreSQLParser.VOLATILE - 357)) | (1 << (PostgreSQLParser.WHITESPACE_P - 357)) | (1 << (PostgreSQLParser.WITHOUT - 357)) | (1 << (PostgreSQLParser.WORK - 357)) | (1 << (PostgreSQLParser.WRAPPER - 357)) | (1 << (PostgreSQLParser.WRITE - 357)) | (1 << (PostgreSQLParser.XML_P - 357)) | (1 << (PostgreSQLParser.YEAR_P - 357)) | (1 << (PostgreSQLParser.YES_P - 357)) | (1 << (PostgreSQLParser.ZONE - 357)) | (1 << (PostgreSQLParser.BETWEEN - 357)) | (1 << (PostgreSQLParser.BIGINT - 357)) | (1 << (PostgreSQLParser.BIT - 357)) | (1 << (PostgreSQLParser.BOOLEAN_P - 357)) | (1 << (PostgreSQLParser.CHAR_P - 357)) | (1 << (PostgreSQLParser.CHARACTER - 357)) | (1 << (PostgreSQLParser.COALESCE - 357)) | (1 << (PostgreSQLParser.DEC - 357)) | (1 << (PostgreSQLParser.DECIMAL_P - 357)) | (1 << (PostgreSQLParser.EXISTS - 357)) | (1 << (PostgreSQLParser.EXTRACT - 357)))) !== 0) || ((((_la - 389)) & ~0x1f) == 0 && ((1 << (_la - 389)) & ((1 << (PostgreSQLParser.FLOAT_P - 389)) | (1 << (PostgreSQLParser.GREATEST - 389)) | (1 << (PostgreSQLParser.INOUT - 389)) | (1 << (PostgreSQLParser.INT_P - 389)) | (1 << (PostgreSQLParser.INTEGER - 389)) | (1 << (PostgreSQLParser.INTERVAL - 389)) | (1 << (PostgreSQLParser.LEAST - 389)) | (1 << (PostgreSQLParser.NATIONAL - 389)) | (1 << (PostgreSQLParser.NCHAR - 389)) | (1 << (PostgreSQLParser.NONE - 389)) | (1 << (PostgreSQLParser.NULLIF - 389)) | (1 << (PostgreSQLParser.NUMERIC - 389)) | (1 << (PostgreSQLParser.OVERLAY - 389)) | (1 << (PostgreSQLParser.POSITION - 389)) | (1 << (PostgreSQLParser.PRECISION - 389)) | (1 << (PostgreSQLParser.REAL - 389)) | (1 << (PostgreSQLParser.ROW - 389)) | (1 << (PostgreSQLParser.SETOF - 389)) | (1 << (PostgreSQLParser.SMALLINT - 389)) | (1 << (PostgreSQLParser.SUBSTRING - 389)) | (1 << (PostgreSQLParser.TIME - 389)) | (1 << (PostgreSQLParser.TIMESTAMP - 389)) | (1 << (PostgreSQLParser.TREAT - 389)) | (1 << (PostgreSQLParser.TRIM - 389)) | (1 << (PostgreSQLParser.VALUES - 389)) | (1 << (PostgreSQLParser.VARCHAR - 389)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 389)) | (1 << (PostgreSQLParser.XMLCONCAT - 389)) | (1 << (PostgreSQLParser.XMLELEMENT - 389)) | (1 << (PostgreSQLParser.XMLEXISTS - 389)) | (1 << (PostgreSQLParser.XMLFOREST - 389)) | (1 << (PostgreSQLParser.XMLPARSE - 389)))) !== 0) || ((((_la - 421)) & ~0x1f) == 0 && ((1 << (_la - 421)) & ((1 << (PostgreSQLParser.XMLPI - 421)) | (1 << (PostgreSQLParser.XMLROOT - 421)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 421)) | (1 << (PostgreSQLParser.CALL - 421)) | (1 << (PostgreSQLParser.CURRENT_P - 421)) | (1 << (PostgreSQLParser.ATTACH - 421)) | (1 << (PostgreSQLParser.DETACH - 421)) | (1 << (PostgreSQLParser.EXPRESSION - 421)) | (1 << (PostgreSQLParser.GENERATED - 421)) | (1 << (PostgreSQLParser.LOGGED - 421)) | (1 << (PostgreSQLParser.STORED - 421)) | (1 << (PostgreSQLParser.INCLUDE - 421)) | (1 << (PostgreSQLParser.ROUTINE - 421)) | (1 << (PostgreSQLParser.TRANSFORM - 421)) | (1 << (PostgreSQLParser.IMPORT_P - 421)) | (1 << (PostgreSQLParser.POLICY - 421)) | (1 << (PostgreSQLParser.METHOD - 421)) | (1 << (PostgreSQLParser.REFERENCING - 421)) | (1 << (PostgreSQLParser.NEW - 421)) | (1 << (PostgreSQLParser.OLD - 421)) | (1 << (PostgreSQLParser.VALUE_P - 421)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 421)) | (1 << (PostgreSQLParser.PUBLICATION - 421)) | (1 << (PostgreSQLParser.OUT_P - 421)) | (1 << (PostgreSQLParser.ROUTINES - 421)) | (1 << (PostgreSQLParser.SCHEMAS - 421)) | (1 << (PostgreSQLParser.PROCEDURES - 421)) | (1 << (PostgreSQLParser.INPUT_P - 421)) | (1 << (PostgreSQLParser.SUPPORT - 421)) | (1 << (PostgreSQLParser.PARALLEL - 421)) | (1 << (PostgreSQLParser.SQL_P - 421)))) !== 0) || ((((_la - 453)) & ~0x1f) == 0 && ((1 << (_la - 453)) & ((1 << (PostgreSQLParser.DEPENDS - 453)) | (1 << (PostgreSQLParser.OVERRIDING - 453)) | (1 << (PostgreSQLParser.CONFLICT - 453)) | (1 << (PostgreSQLParser.SKIP_P - 453)) | (1 << (PostgreSQLParser.LOCKED - 453)) | (1 << (PostgreSQLParser.TIES - 453)) | (1 << (PostgreSQLParser.ROLLUP - 453)) | (1 << (PostgreSQLParser.CUBE - 453)) | (1 << (PostgreSQLParser.GROUPING - 453)) | (1 << (PostgreSQLParser.SETS - 453)) | (1 << (PostgreSQLParser.TABLESAMPLE - 453)) | (1 << (PostgreSQLParser.ORDINALITY - 453)) | (1 << (PostgreSQLParser.XMLTABLE - 453)) | (1 << (PostgreSQLParser.COLUMNS - 453)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 453)) | (1 << (PostgreSQLParser.ROWTYPE - 453)) | (1 << (PostgreSQLParser.NORMALIZED - 453)) | (1 << (PostgreSQLParser.WITHIN - 453)) | (1 << (PostgreSQLParser.FILTER - 453)) | (1 << (PostgreSQLParser.GROUPS - 453)) | (1 << (PostgreSQLParser.OTHERS - 453)) | (1 << (PostgreSQLParser.NFC - 453)) | (1 << (PostgreSQLParser.NFD - 453)) | (1 << (PostgreSQLParser.NFKC - 453)) | (1 << (PostgreSQLParser.NFKD - 453)) | (1 << (PostgreSQLParser.UESCAPE - 453)) | (1 << (PostgreSQLParser.VIEWS - 453)) | (1 << (PostgreSQLParser.NORMALIZE - 453)) | (1 << (PostgreSQLParser.DUMP - 453)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 453)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 453)) | (1 << (PostgreSQLParser.ERROR - 453)))) !== 0) || ((((_la - 485)) & ~0x1f) == 0 && ((1 << (_la - 485)) & ((1 << (PostgreSQLParser.USE_VARIABLE - 485)) | (1 << (PostgreSQLParser.USE_COLUMN - 485)) | (1 << (PostgreSQLParser.ALIAS - 485)) | (1 << (PostgreSQLParser.CONSTANT - 485)) | (1 << (PostgreSQLParser.PERFORM - 485)) | (1 << (PostgreSQLParser.GET - 485)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 485)) | (1 << (PostgreSQLParser.STACKED - 485)) | (1 << (PostgreSQLParser.ELSIF - 485)) | (1 << (PostgreSQLParser.REVERSE - 485)) | (1 << (PostgreSQLParser.SLICE - 485)) | (1 << (PostgreSQLParser.EXIT - 485)) | (1 << (PostgreSQLParser.RETURN - 485)) | (1 << (PostgreSQLParser.QUERY - 485)) | (1 << (PostgreSQLParser.RAISE - 485)) | (1 << (PostgreSQLParser.SQLSTATE - 485)) | (1 << (PostgreSQLParser.DEBUG - 485)) | (1 << (PostgreSQLParser.LOG - 485)) | (1 << (PostgreSQLParser.INFO - 485)) | (1 << (PostgreSQLParser.NOTICE - 485)) | (1 << (PostgreSQLParser.WARNING - 485)) | (1 << (PostgreSQLParser.EXCEPTION - 485)) | (1 << (PostgreSQLParser.ASSERT - 485)) | (1 << (PostgreSQLParser.OPEN - 485)) | (1 << (PostgreSQLParser.Identifier - 485)) | (1 << (PostgreSQLParser.QuotedIdentifier - 485)))) !== 0) || ((((_la - 517)) & ~0x1f) == 0 && ((1 << (_la - 517)) & ((1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 517)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 517)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 517)))) !== 0)) { + this.state = 5402; + this.func_args_with_defaults_list(); + } + + this.state = 5405; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_args_with_defaults_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_args_with_defaults_list; + return this; +} + +Func_args_with_defaults_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_args_with_defaults_listContext.prototype.constructor = Func_args_with_defaults_listContext; + +Func_args_with_defaults_listContext.prototype.func_arg_with_default = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Func_arg_with_defaultContext); + } else { + return this.getTypedRuleContext(Func_arg_with_defaultContext,i); + } +}; + +Func_args_with_defaults_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Func_args_with_defaults_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_args_with_defaults_list(this); + } +}; + +Func_args_with_defaults_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_args_with_defaults_list(this); + } +}; + +Func_args_with_defaults_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_args_with_defaults_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_args_with_defaults_listContext = Func_args_with_defaults_listContext; + +PostgreSQLParser.prototype.func_args_with_defaults_list = function() { + + var localctx = new Func_args_with_defaults_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 630, PostgreSQLParser.RULE_func_args_with_defaults_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5407; + this.func_arg_with_default(); + this.state = 5412; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5408; + this.match(PostgreSQLParser.COMMA); + this.state = 5409; + this.func_arg_with_default(); + this.state = 5414; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_arg; + return this; +} + +Func_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_argContext.prototype.constructor = Func_argContext; + +Func_argContext.prototype.arg_class = function() { + return this.getTypedRuleContext(Arg_classContext,0); +}; + +Func_argContext.prototype.func_type = function() { + return this.getTypedRuleContext(Func_typeContext,0); +}; + +Func_argContext.prototype.param_name = function() { + return this.getTypedRuleContext(Param_nameContext,0); +}; + +Func_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_arg(this); + } +}; + +Func_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_arg(this); + } +}; + +Func_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_argContext = Func_argContext; + +PostgreSQLParser.prototype.func_arg = function() { + + var localctx = new Func_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 632, PostgreSQLParser.RULE_func_arg); + try { + this.state = 5428; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,275,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5415; + this.arg_class(); + this.state = 5417; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,273,this._ctx); + if(la_===1) { + this.state = 5416; + this.param_name(); + + } + this.state = 5419; + this.func_type(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5421; + this.param_name(); + this.state = 5423; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,274,this._ctx); + if(la_===1) { + this.state = 5422; + this.arg_class(); + + } + this.state = 5425; + this.func_type(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5427; + this.func_type(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Arg_classContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_arg_class; + return this; +} + +Arg_classContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Arg_classContext.prototype.constructor = Arg_classContext; + +Arg_classContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +Arg_classContext.prototype.OUT_P = function() { + return this.getToken(PostgreSQLParser.OUT_P, 0); +}; + +Arg_classContext.prototype.INOUT = function() { + return this.getToken(PostgreSQLParser.INOUT, 0); +}; + +Arg_classContext.prototype.VARIADIC = function() { + return this.getToken(PostgreSQLParser.VARIADIC, 0); +}; + +Arg_classContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterArg_class(this); + } +}; + +Arg_classContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitArg_class(this); + } +}; + +Arg_classContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitArg_class(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Arg_classContext = Arg_classContext; + +PostgreSQLParser.prototype.arg_class = function() { + + var localctx = new Arg_classContext(this, this._ctx, this.state); + this.enterRule(localctx, 634, PostgreSQLParser.RULE_arg_class); + try { + this.state = 5437; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.IN_P: + this.enterOuterAlt(localctx, 1); + this.state = 5430; + this.match(PostgreSQLParser.IN_P); + this.state = 5432; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,276,this._ctx); + if(la_===1) { + this.state = 5431; + this.match(PostgreSQLParser.OUT_P); + + } + break; + case PostgreSQLParser.OUT_P: + this.enterOuterAlt(localctx, 2); + this.state = 5434; + this.match(PostgreSQLParser.OUT_P); + break; + case PostgreSQLParser.INOUT: + this.enterOuterAlt(localctx, 3); + this.state = 5435; + this.match(PostgreSQLParser.INOUT); + break; + case PostgreSQLParser.VARIADIC: + this.enterOuterAlt(localctx, 4); + this.state = 5436; + this.match(PostgreSQLParser.VARIADIC); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Param_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_param_name; + return this; +} + +Param_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Param_nameContext.prototype.constructor = Param_nameContext; + +Param_nameContext.prototype.type_function_name = function() { + return this.getTypedRuleContext(Type_function_nameContext,0); +}; + +Param_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterParam_name(this); + } +}; + +Param_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitParam_name(this); + } +}; + +Param_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitParam_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Param_nameContext = Param_nameContext; + +PostgreSQLParser.prototype.param_name = function() { + + var localctx = new Param_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 636, PostgreSQLParser.RULE_param_name); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5439; + this.type_function_name(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_returnContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_return; + return this; +} + +Func_returnContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_returnContext.prototype.constructor = Func_returnContext; + +Func_returnContext.prototype.func_type = function() { + return this.getTypedRuleContext(Func_typeContext,0); +}; + +Func_returnContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_return(this); + } +}; + +Func_returnContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_return(this); + } +}; + +Func_returnContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_return(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_returnContext = Func_returnContext; + +PostgreSQLParser.prototype.func_return = function() { + + var localctx = new Func_returnContext(this, this._ctx, this.state); + this.enterRule(localctx, 638, PostgreSQLParser.RULE_func_return); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5441; + this.func_type(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_typeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_type; + return this; +} + +Func_typeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_typeContext.prototype.constructor = Func_typeContext; + +Func_typeContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +Func_typeContext.prototype.type_function_name = function() { + return this.getTypedRuleContext(Type_function_nameContext,0); +}; + +Func_typeContext.prototype.attrs = function() { + return this.getTypedRuleContext(AttrsContext,0); +}; + +Func_typeContext.prototype.PERCENT = function() { + return this.getToken(PostgreSQLParser.PERCENT, 0); +}; + +Func_typeContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +Func_typeContext.prototype.SETOF = function() { + return this.getToken(PostgreSQLParser.SETOF, 0); +}; + +Func_typeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_type(this); + } +}; + +Func_typeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_type(this); + } +}; + +Func_typeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_type(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_typeContext = Func_typeContext; + +PostgreSQLParser.prototype.func_type = function() { + + var localctx = new Func_typeContext(this, this._ctx, this.state); + this.enterRule(localctx, 640, PostgreSQLParser.RULE_func_type); + try { + this.state = 5455; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,278,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5443; + this.typename(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5444; + this.type_function_name(); + this.state = 5445; + this.attrs(); + this.state = 5446; + this.match(PostgreSQLParser.PERCENT); + this.state = 5447; + this.match(PostgreSQLParser.TYPE_P); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5449; + this.match(PostgreSQLParser.SETOF); + this.state = 5450; + this.type_function_name(); + this.state = 5451; + this.attrs(); + this.state = 5452; + this.match(PostgreSQLParser.PERCENT); + this.state = 5453; + this.match(PostgreSQLParser.TYPE_P); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_arg_with_defaultContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_arg_with_default; + return this; +} + +Func_arg_with_defaultContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_arg_with_defaultContext.prototype.constructor = Func_arg_with_defaultContext; + +Func_arg_with_defaultContext.prototype.func_arg = function() { + return this.getTypedRuleContext(Func_argContext,0); +}; + +Func_arg_with_defaultContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Func_arg_with_defaultContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Func_arg_with_defaultContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +Func_arg_with_defaultContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_arg_with_default(this); + } +}; + +Func_arg_with_defaultContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_arg_with_default(this); + } +}; + +Func_arg_with_defaultContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_arg_with_default(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_arg_with_defaultContext = Func_arg_with_defaultContext; + +PostgreSQLParser.prototype.func_arg_with_default = function() { + + var localctx = new Func_arg_with_defaultContext(this, this._ctx, this.state); + this.enterRule(localctx, 642, PostgreSQLParser.RULE_func_arg_with_default); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5457; + this.func_arg(); + this.state = 5460; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.EQUAL || _la===PostgreSQLParser.DEFAULT) { + this.state = 5458; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.EQUAL || _la===PostgreSQLParser.DEFAULT)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 5459; + this.a_expr(); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Aggr_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_aggr_arg; + return this; +} + +Aggr_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Aggr_argContext.prototype.constructor = Aggr_argContext; + +Aggr_argContext.prototype.func_arg = function() { + return this.getTypedRuleContext(Func_argContext,0); +}; + +Aggr_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAggr_arg(this); + } +}; + +Aggr_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAggr_arg(this); + } +}; + +Aggr_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAggr_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Aggr_argContext = Aggr_argContext; + +PostgreSQLParser.prototype.aggr_arg = function() { + + var localctx = new Aggr_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 644, PostgreSQLParser.RULE_aggr_arg); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5462; + this.func_arg(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Aggr_argsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_aggr_args; + return this; +} + +Aggr_argsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Aggr_argsContext.prototype.constructor = Aggr_argsContext; + +Aggr_argsContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Aggr_argsContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Aggr_argsContext.prototype.STAR = function() { + return this.getToken(PostgreSQLParser.STAR, 0); +}; + +Aggr_argsContext.prototype.aggr_args_list = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Aggr_args_listContext); + } else { + return this.getTypedRuleContext(Aggr_args_listContext,i); + } +}; + +Aggr_argsContext.prototype.ORDER = function() { + return this.getToken(PostgreSQLParser.ORDER, 0); +}; + +Aggr_argsContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Aggr_argsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAggr_args(this); + } +}; + +Aggr_argsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAggr_args(this); + } +}; + +Aggr_argsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAggr_args(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Aggr_argsContext = Aggr_argsContext; + +PostgreSQLParser.prototype.aggr_args = function() { + + var localctx = new Aggr_argsContext(this, this._ctx, this.state); + this.enterRule(localctx, 646, PostgreSQLParser.RULE_aggr_args); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5464; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5475; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,280,this._ctx); + switch(la_) { + case 1: + this.state = 5465; + this.match(PostgreSQLParser.STAR); + break; + + case 2: + this.state = 5466; + this.aggr_args_list(); + break; + + case 3: + this.state = 5467; + this.match(PostgreSQLParser.ORDER); + this.state = 5468; + this.match(PostgreSQLParser.BY); + this.state = 5469; + this.aggr_args_list(); + break; + + case 4: + this.state = 5470; + this.aggr_args_list(); + this.state = 5471; + this.match(PostgreSQLParser.ORDER); + this.state = 5472; + this.match(PostgreSQLParser.BY); + this.state = 5473; + this.aggr_args_list(); + break; + + } + this.state = 5477; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Aggr_args_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_aggr_args_list; + return this; +} + +Aggr_args_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Aggr_args_listContext.prototype.constructor = Aggr_args_listContext; + +Aggr_args_listContext.prototype.aggr_arg = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Aggr_argContext); + } else { + return this.getTypedRuleContext(Aggr_argContext,i); + } +}; + +Aggr_args_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Aggr_args_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAggr_args_list(this); + } +}; + +Aggr_args_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAggr_args_list(this); + } +}; + +Aggr_args_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAggr_args_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Aggr_args_listContext = Aggr_args_listContext; + +PostgreSQLParser.prototype.aggr_args_list = function() { + + var localctx = new Aggr_args_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 648, PostgreSQLParser.RULE_aggr_args_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5479; + this.aggr_arg(); + this.state = 5484; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5480; + this.match(PostgreSQLParser.COMMA); + this.state = 5481; + this.aggr_arg(); + this.state = 5486; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Aggregate_with_argtypesContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_aggregate_with_argtypes; + return this; +} + +Aggregate_with_argtypesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Aggregate_with_argtypesContext.prototype.constructor = Aggregate_with_argtypesContext; + +Aggregate_with_argtypesContext.prototype.func_name = function() { + return this.getTypedRuleContext(Func_nameContext,0); +}; + +Aggregate_with_argtypesContext.prototype.aggr_args = function() { + return this.getTypedRuleContext(Aggr_argsContext,0); +}; + +Aggregate_with_argtypesContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAggregate_with_argtypes(this); + } +}; + +Aggregate_with_argtypesContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAggregate_with_argtypes(this); + } +}; + +Aggregate_with_argtypesContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAggregate_with_argtypes(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Aggregate_with_argtypesContext = Aggregate_with_argtypesContext; + +PostgreSQLParser.prototype.aggregate_with_argtypes = function() { + + var localctx = new Aggregate_with_argtypesContext(this, this._ctx, this.state); + this.enterRule(localctx, 650, PostgreSQLParser.RULE_aggregate_with_argtypes); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5487; + this.func_name(); + this.state = 5488; + this.aggr_args(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Aggregate_with_argtypes_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_aggregate_with_argtypes_list; + return this; +} + +Aggregate_with_argtypes_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Aggregate_with_argtypes_listContext.prototype.constructor = Aggregate_with_argtypes_listContext; + +Aggregate_with_argtypes_listContext.prototype.aggregate_with_argtypes = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Aggregate_with_argtypesContext); + } else { + return this.getTypedRuleContext(Aggregate_with_argtypesContext,i); + } +}; + +Aggregate_with_argtypes_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Aggregate_with_argtypes_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAggregate_with_argtypes_list(this); + } +}; + +Aggregate_with_argtypes_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAggregate_with_argtypes_list(this); + } +}; + +Aggregate_with_argtypes_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAggregate_with_argtypes_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Aggregate_with_argtypes_listContext = Aggregate_with_argtypes_listContext; + +PostgreSQLParser.prototype.aggregate_with_argtypes_list = function() { + + var localctx = new Aggregate_with_argtypes_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 652, PostgreSQLParser.RULE_aggregate_with_argtypes_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5490; + this.aggregate_with_argtypes(); + this.state = 5495; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5491; + this.match(PostgreSQLParser.COMMA); + this.state = 5492; + this.aggregate_with_argtypes(); + this.state = 5497; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Createfunc_opt_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createfunc_opt_list; + return this; +} + +Createfunc_opt_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Createfunc_opt_listContext.prototype.constructor = Createfunc_opt_listContext; + +Createfunc_opt_listContext.prototype.createfunc_opt_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Createfunc_opt_itemContext); + } else { + return this.getTypedRuleContext(Createfunc_opt_itemContext,i); + } +}; + +Createfunc_opt_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatefunc_opt_list(this); + } +}; + +Createfunc_opt_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatefunc_opt_list(this); + } +}; + +Createfunc_opt_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatefunc_opt_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Createfunc_opt_listContext = Createfunc_opt_listContext; + +PostgreSQLParser.prototype.createfunc_opt_list = function() { + + var localctx = new Createfunc_opt_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 654, PostgreSQLParser.RULE_createfunc_opt_list); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5499; + this._errHandler.sync(this); + var _alt = 1; + do { + switch (_alt) { + case 1: + this.state = 5498; + this.createfunc_opt_item(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 5501; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,283, this._ctx); + } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER ); + + ParseRoutineBody(_localctx); + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Common_func_opt_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_common_func_opt_item; + return this; +} + +Common_func_opt_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Common_func_opt_itemContext.prototype.constructor = Common_func_opt_itemContext; + +Common_func_opt_itemContext.prototype.CALLED = function() { + return this.getToken(PostgreSQLParser.CALLED, 0); +}; + +Common_func_opt_itemContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +Common_func_opt_itemContext.prototype.NULL_P = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.NULL_P); + } else { + return this.getToken(PostgreSQLParser.NULL_P, i); + } +}; + + +Common_func_opt_itemContext.prototype.INPUT_P = function() { + return this.getToken(PostgreSQLParser.INPUT_P, 0); +}; + +Common_func_opt_itemContext.prototype.RETURNS = function() { + return this.getToken(PostgreSQLParser.RETURNS, 0); +}; + +Common_func_opt_itemContext.prototype.STRICT_P = function() { + return this.getToken(PostgreSQLParser.STRICT_P, 0); +}; + +Common_func_opt_itemContext.prototype.IMMUTABLE = function() { + return this.getToken(PostgreSQLParser.IMMUTABLE, 0); +}; + +Common_func_opt_itemContext.prototype.STABLE = function() { + return this.getToken(PostgreSQLParser.STABLE, 0); +}; + +Common_func_opt_itemContext.prototype.VOLATILE = function() { + return this.getToken(PostgreSQLParser.VOLATILE, 0); +}; + +Common_func_opt_itemContext.prototype.EXTERNAL = function() { + return this.getToken(PostgreSQLParser.EXTERNAL, 0); +}; + +Common_func_opt_itemContext.prototype.SECURITY = function() { + return this.getToken(PostgreSQLParser.SECURITY, 0); +}; + +Common_func_opt_itemContext.prototype.DEFINER = function() { + return this.getToken(PostgreSQLParser.DEFINER, 0); +}; + +Common_func_opt_itemContext.prototype.INVOKER = function() { + return this.getToken(PostgreSQLParser.INVOKER, 0); +}; + +Common_func_opt_itemContext.prototype.LEAKPROOF = function() { + return this.getToken(PostgreSQLParser.LEAKPROOF, 0); +}; + +Common_func_opt_itemContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +Common_func_opt_itemContext.prototype.COST = function() { + return this.getToken(PostgreSQLParser.COST, 0); +}; + +Common_func_opt_itemContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +Common_func_opt_itemContext.prototype.ROWS = function() { + return this.getToken(PostgreSQLParser.ROWS, 0); +}; + +Common_func_opt_itemContext.prototype.SUPPORT = function() { + return this.getToken(PostgreSQLParser.SUPPORT, 0); +}; + +Common_func_opt_itemContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Common_func_opt_itemContext.prototype.functionsetresetclause = function() { + return this.getTypedRuleContext(FunctionsetresetclauseContext,0); +}; + +Common_func_opt_itemContext.prototype.PARALLEL = function() { + return this.getToken(PostgreSQLParser.PARALLEL, 0); +}; + +Common_func_opt_itemContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Common_func_opt_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCommon_func_opt_item(this); + } +}; + +Common_func_opt_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCommon_func_opt_item(this); + } +}; + +Common_func_opt_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCommon_func_opt_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Common_func_opt_itemContext = Common_func_opt_itemContext; + +PostgreSQLParser.prototype.common_func_opt_item = function() { + + var localctx = new Common_func_opt_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 656, PostgreSQLParser.RULE_common_func_opt_item); + try { + this.state = 5540; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,284,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5505; + this.match(PostgreSQLParser.CALLED); + this.state = 5506; + this.match(PostgreSQLParser.ON); + this.state = 5507; + this.match(PostgreSQLParser.NULL_P); + this.state = 5508; + this.match(PostgreSQLParser.INPUT_P); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5509; + this.match(PostgreSQLParser.RETURNS); + this.state = 5510; + this.match(PostgreSQLParser.NULL_P); + this.state = 5511; + this.match(PostgreSQLParser.ON); + this.state = 5512; + this.match(PostgreSQLParser.NULL_P); + this.state = 5513; + this.match(PostgreSQLParser.INPUT_P); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5514; + this.match(PostgreSQLParser.STRICT_P); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 5515; + this.match(PostgreSQLParser.IMMUTABLE); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 5516; + this.match(PostgreSQLParser.STABLE); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 5517; + this.match(PostgreSQLParser.VOLATILE); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 5518; + this.match(PostgreSQLParser.EXTERNAL); + this.state = 5519; + this.match(PostgreSQLParser.SECURITY); + this.state = 5520; + this.match(PostgreSQLParser.DEFINER); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 5521; + this.match(PostgreSQLParser.EXTERNAL); + this.state = 5522; + this.match(PostgreSQLParser.SECURITY); + this.state = 5523; + this.match(PostgreSQLParser.INVOKER); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 5524; + this.match(PostgreSQLParser.SECURITY); + this.state = 5525; + this.match(PostgreSQLParser.DEFINER); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 5526; + this.match(PostgreSQLParser.SECURITY); + this.state = 5527; + this.match(PostgreSQLParser.INVOKER); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 5528; + this.match(PostgreSQLParser.LEAKPROOF); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 5529; + this.match(PostgreSQLParser.NOT); + this.state = 5530; + this.match(PostgreSQLParser.LEAKPROOF); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 5531; + this.match(PostgreSQLParser.COST); + this.state = 5532; + this.numericonly(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 5533; + this.match(PostgreSQLParser.ROWS); + this.state = 5534; + this.numericonly(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 5535; + this.match(PostgreSQLParser.SUPPORT); + this.state = 5536; + this.any_name(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 5537; + this.functionsetresetclause(); + break; + + case 17: + this.enterOuterAlt(localctx, 17); + this.state = 5538; + this.match(PostgreSQLParser.PARALLEL); + this.state = 5539; + this.colid(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Createfunc_opt_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createfunc_opt_item; + return this; +} + +Createfunc_opt_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Createfunc_opt_itemContext.prototype.constructor = Createfunc_opt_itemContext; + +Createfunc_opt_itemContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Createfunc_opt_itemContext.prototype.func_as = function() { + return this.getTypedRuleContext(Func_asContext,0); +}; + +Createfunc_opt_itemContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +Createfunc_opt_itemContext.prototype.nonreservedword_or_sconst = function() { + return this.getTypedRuleContext(Nonreservedword_or_sconstContext,0); +}; + +Createfunc_opt_itemContext.prototype.TRANSFORM = function() { + return this.getToken(PostgreSQLParser.TRANSFORM, 0); +}; + +Createfunc_opt_itemContext.prototype.transform_type_list = function() { + return this.getTypedRuleContext(Transform_type_listContext,0); +}; + +Createfunc_opt_itemContext.prototype.WINDOW = function() { + return this.getToken(PostgreSQLParser.WINDOW, 0); +}; + +Createfunc_opt_itemContext.prototype.common_func_opt_item = function() { + return this.getTypedRuleContext(Common_func_opt_itemContext,0); +}; + +Createfunc_opt_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatefunc_opt_item(this); + } +}; + +Createfunc_opt_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatefunc_opt_item(this); + } +}; + +Createfunc_opt_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatefunc_opt_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Createfunc_opt_itemContext = Createfunc_opt_itemContext; + +PostgreSQLParser.prototype.createfunc_opt_item = function() { + + var localctx = new Createfunc_opt_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 658, PostgreSQLParser.RULE_createfunc_opt_item); + try { + this.state = 5550; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AS: + this.enterOuterAlt(localctx, 1); + this.state = 5542; + this.match(PostgreSQLParser.AS); + this.state = 5543; + this.func_as(); + break; + case PostgreSQLParser.LANGUAGE: + this.enterOuterAlt(localctx, 2); + this.state = 5544; + this.match(PostgreSQLParser.LANGUAGE); + this.state = 5545; + this.nonreservedword_or_sconst(); + break; + case PostgreSQLParser.TRANSFORM: + this.enterOuterAlt(localctx, 3); + this.state = 5546; + this.match(PostgreSQLParser.TRANSFORM); + this.state = 5547; + this.transform_type_list(); + break; + case PostgreSQLParser.WINDOW: + this.enterOuterAlt(localctx, 4); + this.state = 5548; + this.match(PostgreSQLParser.WINDOW); + break; + case PostgreSQLParser.NOT: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.COST: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + this.enterOuterAlt(localctx, 5); + this.state = 5549; + this.common_func_opt_item(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_asContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_as; + this.Definition = null + this.def = null; // SconstContext + return this; +} + +Func_asContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_asContext.prototype.constructor = Func_asContext; + +Func_asContext.prototype.sconst = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(SconstContext); + } else { + return this.getTypedRuleContext(SconstContext,i); + } +}; + +Func_asContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +Func_asContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_as(this); + } +}; + +Func_asContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_as(this); + } +}; + +Func_asContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_as(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_asContext = Func_asContext; + +PostgreSQLParser.prototype.func_as = function() { + + var localctx = new Func_asContext(this, this._ctx, this.state); + this.enterRule(localctx, 660, PostgreSQLParser.RULE_func_as); + try { + this.state = 5557; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,286,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5552; + localctx.def = this.sconst(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5553; + this.sconst(); + this.state = 5554; + this.match(PostgreSQLParser.COMMA); + this.state = 5555; + this.sconst(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Transform_type_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_transform_type_list; + return this; +} + +Transform_type_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Transform_type_listContext.prototype.constructor = Transform_type_listContext; + +Transform_type_listContext.prototype.FOR = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.FOR); + } else { + return this.getToken(PostgreSQLParser.FOR, i); + } +}; + + +Transform_type_listContext.prototype.TYPE_P = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.TYPE_P); + } else { + return this.getToken(PostgreSQLParser.TYPE_P, i); + } +}; + + +Transform_type_listContext.prototype.typename = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TypenameContext); + } else { + return this.getTypedRuleContext(TypenameContext,i); + } +}; + +Transform_type_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Transform_type_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTransform_type_list(this); + } +}; + +Transform_type_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTransform_type_list(this); + } +}; + +Transform_type_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTransform_type_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Transform_type_listContext = Transform_type_listContext; + +PostgreSQLParser.prototype.transform_type_list = function() { + + var localctx = new Transform_type_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 662, PostgreSQLParser.RULE_transform_type_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5559; + this.match(PostgreSQLParser.FOR); + this.state = 5560; + this.match(PostgreSQLParser.TYPE_P); + this.state = 5561; + this.typename(); + this.state = 5568; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5562; + this.match(PostgreSQLParser.COMMA); + this.state = 5563; + this.match(PostgreSQLParser.FOR); + this.state = 5564; + this.match(PostgreSQLParser.TYPE_P); + this.state = 5565; + this.typename(); + this.state = 5570; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_definitionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_definition; + return this; +} + +Opt_definitionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_definitionContext.prototype.constructor = Opt_definitionContext; + +Opt_definitionContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Opt_definitionContext.prototype.definition = function() { + return this.getTypedRuleContext(DefinitionContext,0); +}; + +Opt_definitionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_definition(this); + } +}; + +Opt_definitionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_definition(this); + } +}; + +Opt_definitionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_definition(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_definitionContext = Opt_definitionContext; + +PostgreSQLParser.prototype.opt_definition = function() { + + var localctx = new Opt_definitionContext(this, this._ctx, this.state); + this.enterRule(localctx, 664, PostgreSQLParser.RULE_opt_definition); + try { + this.state = 5574; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,288,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5571; + this.match(PostgreSQLParser.WITH); + this.state = 5572; + this.definition(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Table_func_columnContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_table_func_column; + return this; +} + +Table_func_columnContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Table_func_columnContext.prototype.constructor = Table_func_columnContext; + +Table_func_columnContext.prototype.param_name = function() { + return this.getTypedRuleContext(Param_nameContext,0); +}; + +Table_func_columnContext.prototype.func_type = function() { + return this.getTypedRuleContext(Func_typeContext,0); +}; + +Table_func_columnContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTable_func_column(this); + } +}; + +Table_func_columnContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTable_func_column(this); + } +}; + +Table_func_columnContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTable_func_column(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Table_func_columnContext = Table_func_columnContext; + +PostgreSQLParser.prototype.table_func_column = function() { + + var localctx = new Table_func_columnContext(this, this._ctx, this.state); + this.enterRule(localctx, 666, PostgreSQLParser.RULE_table_func_column); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5576; + this.param_name(); + this.state = 5577; + this.func_type(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Table_func_column_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_table_func_column_list; + return this; +} + +Table_func_column_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Table_func_column_listContext.prototype.constructor = Table_func_column_listContext; + +Table_func_column_listContext.prototype.table_func_column = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Table_func_columnContext); + } else { + return this.getTypedRuleContext(Table_func_columnContext,i); + } +}; + +Table_func_column_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Table_func_column_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTable_func_column_list(this); + } +}; + +Table_func_column_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTable_func_column_list(this); + } +}; + +Table_func_column_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTable_func_column_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Table_func_column_listContext = Table_func_column_listContext; + +PostgreSQLParser.prototype.table_func_column_list = function() { + + var localctx = new Table_func_column_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 668, PostgreSQLParser.RULE_table_func_column_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5579; + this.table_func_column(); + this.state = 5584; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5580; + this.match(PostgreSQLParser.COMMA); + this.state = 5581; + this.table_func_column(); + this.state = 5586; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterfunctionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterfunctionstmt; + return this; +} + +AlterfunctionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterfunctionstmtContext.prototype.constructor = AlterfunctionstmtContext; + +AlterfunctionstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterfunctionstmtContext.prototype.function_with_argtypes = function() { + return this.getTypedRuleContext(Function_with_argtypesContext,0); +}; + +AlterfunctionstmtContext.prototype.alterfunc_opt_list = function() { + return this.getTypedRuleContext(Alterfunc_opt_listContext,0); +}; + +AlterfunctionstmtContext.prototype.opt_restrict = function() { + return this.getTypedRuleContext(Opt_restrictContext,0); +}; + +AlterfunctionstmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +AlterfunctionstmtContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +AlterfunctionstmtContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +AlterfunctionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterfunctionstmt(this); + } +}; + +AlterfunctionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterfunctionstmt(this); + } +}; + +AlterfunctionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterfunctionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterfunctionstmtContext = AlterfunctionstmtContext; + +PostgreSQLParser.prototype.alterfunctionstmt = function() { + + var localctx = new AlterfunctionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 670, PostgreSQLParser.RULE_alterfunctionstmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5587; + this.match(PostgreSQLParser.ALTER); + this.state = 5588; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FUNCTION || _la===PostgreSQLParser.PROCEDURE || _la===PostgreSQLParser.ROUTINE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 5589; + this.function_with_argtypes(); + this.state = 5590; + this.alterfunc_opt_list(); + this.state = 5591; + this.opt_restrict(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alterfunc_opt_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterfunc_opt_list; + return this; +} + +Alterfunc_opt_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alterfunc_opt_listContext.prototype.constructor = Alterfunc_opt_listContext; + +Alterfunc_opt_listContext.prototype.common_func_opt_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Common_func_opt_itemContext); + } else { + return this.getTypedRuleContext(Common_func_opt_itemContext,i); + } +}; + +Alterfunc_opt_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterfunc_opt_list(this); + } +}; + +Alterfunc_opt_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterfunc_opt_list(this); + } +}; + +Alterfunc_opt_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterfunc_opt_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alterfunc_opt_listContext = Alterfunc_opt_listContext; + +PostgreSQLParser.prototype.alterfunc_opt_list = function() { + + var localctx = new Alterfunc_opt_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 672, PostgreSQLParser.RULE_alterfunc_opt_list); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5594; + this._errHandler.sync(this); + var _alt = 1; + do { + switch (_alt) { + case 1: + this.state = 5593; + this.common_func_opt_item(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 5596; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,290, this._ctx); + } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER ); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_restrictContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_restrict; + return this; +} + +Opt_restrictContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_restrictContext.prototype.constructor = Opt_restrictContext; + +Opt_restrictContext.prototype.RESTRICT = function() { + return this.getToken(PostgreSQLParser.RESTRICT, 0); +}; + +Opt_restrictContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_restrict(this); + } +}; + +Opt_restrictContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_restrict(this); + } +}; + +Opt_restrictContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_restrict(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_restrictContext = Opt_restrictContext; + +PostgreSQLParser.prototype.opt_restrict = function() { + + var localctx = new Opt_restrictContext(this, this._ctx, this.state); + this.enterRule(localctx, 674, PostgreSQLParser.RULE_opt_restrict); + try { + this.state = 5600; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.RESTRICT: + this.enterOuterAlt(localctx, 1); + this.state = 5598; + this.match(PostgreSQLParser.RESTRICT); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RemovefuncstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_removefuncstmt; + return this; +} + +RemovefuncstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RemovefuncstmtContext.prototype.constructor = RemovefuncstmtContext; + +RemovefuncstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +RemovefuncstmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +RemovefuncstmtContext.prototype.function_with_argtypes_list = function() { + return this.getTypedRuleContext(Function_with_argtypes_listContext,0); +}; + +RemovefuncstmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +RemovefuncstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +RemovefuncstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +RemovefuncstmtContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +RemovefuncstmtContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +RemovefuncstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRemovefuncstmt(this); + } +}; + +RemovefuncstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRemovefuncstmt(this); + } +}; + +RemovefuncstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRemovefuncstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RemovefuncstmtContext = RemovefuncstmtContext; + +PostgreSQLParser.prototype.removefuncstmt = function() { + + var localctx = new RemovefuncstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 676, PostgreSQLParser.RULE_removefuncstmt); + try { + this.state = 5638; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,292,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5602; + this.match(PostgreSQLParser.DROP); + this.state = 5603; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5604; + this.function_with_argtypes_list(); + this.state = 5605; + this.opt_drop_behavior(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5607; + this.match(PostgreSQLParser.DROP); + this.state = 5608; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5609; + this.match(PostgreSQLParser.IF_P); + this.state = 5610; + this.match(PostgreSQLParser.EXISTS); + this.state = 5611; + this.function_with_argtypes_list(); + this.state = 5612; + this.opt_drop_behavior(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5614; + this.match(PostgreSQLParser.DROP); + this.state = 5615; + this.match(PostgreSQLParser.PROCEDURE); + this.state = 5616; + this.function_with_argtypes_list(); + this.state = 5617; + this.opt_drop_behavior(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 5619; + this.match(PostgreSQLParser.DROP); + this.state = 5620; + this.match(PostgreSQLParser.PROCEDURE); + this.state = 5621; + this.match(PostgreSQLParser.IF_P); + this.state = 5622; + this.match(PostgreSQLParser.EXISTS); + this.state = 5623; + this.function_with_argtypes_list(); + this.state = 5624; + this.opt_drop_behavior(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 5626; + this.match(PostgreSQLParser.DROP); + this.state = 5627; + this.match(PostgreSQLParser.ROUTINE); + this.state = 5628; + this.function_with_argtypes_list(); + this.state = 5629; + this.opt_drop_behavior(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 5631; + this.match(PostgreSQLParser.DROP); + this.state = 5632; + this.match(PostgreSQLParser.ROUTINE); + this.state = 5633; + this.match(PostgreSQLParser.IF_P); + this.state = 5634; + this.match(PostgreSQLParser.EXISTS); + this.state = 5635; + this.function_with_argtypes_list(); + this.state = 5636; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RemoveaggrstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_removeaggrstmt; + return this; +} + +RemoveaggrstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RemoveaggrstmtContext.prototype.constructor = RemoveaggrstmtContext; + +RemoveaggrstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +RemoveaggrstmtContext.prototype.AGGREGATE = function() { + return this.getToken(PostgreSQLParser.AGGREGATE, 0); +}; + +RemoveaggrstmtContext.prototype.aggregate_with_argtypes_list = function() { + return this.getTypedRuleContext(Aggregate_with_argtypes_listContext,0); +}; + +RemoveaggrstmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +RemoveaggrstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +RemoveaggrstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +RemoveaggrstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRemoveaggrstmt(this); + } +}; + +RemoveaggrstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRemoveaggrstmt(this); + } +}; + +RemoveaggrstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRemoveaggrstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RemoveaggrstmtContext = RemoveaggrstmtContext; + +PostgreSQLParser.prototype.removeaggrstmt = function() { + + var localctx = new RemoveaggrstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 678, PostgreSQLParser.RULE_removeaggrstmt); + try { + this.state = 5652; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,293,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5640; + this.match(PostgreSQLParser.DROP); + this.state = 5641; + this.match(PostgreSQLParser.AGGREGATE); + this.state = 5642; + this.aggregate_with_argtypes_list(); + this.state = 5643; + this.opt_drop_behavior(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5645; + this.match(PostgreSQLParser.DROP); + this.state = 5646; + this.match(PostgreSQLParser.AGGREGATE); + this.state = 5647; + this.match(PostgreSQLParser.IF_P); + this.state = 5648; + this.match(PostgreSQLParser.EXISTS); + this.state = 5649; + this.aggregate_with_argtypes_list(); + this.state = 5650; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RemoveoperstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_removeoperstmt; + return this; +} + +RemoveoperstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RemoveoperstmtContext.prototype.constructor = RemoveoperstmtContext; + +RemoveoperstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +RemoveoperstmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +RemoveoperstmtContext.prototype.operator_with_argtypes_list = function() { + return this.getTypedRuleContext(Operator_with_argtypes_listContext,0); +}; + +RemoveoperstmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +RemoveoperstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +RemoveoperstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +RemoveoperstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRemoveoperstmt(this); + } +}; + +RemoveoperstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRemoveoperstmt(this); + } +}; + +RemoveoperstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRemoveoperstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RemoveoperstmtContext = RemoveoperstmtContext; + +PostgreSQLParser.prototype.removeoperstmt = function() { + + var localctx = new RemoveoperstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 680, PostgreSQLParser.RULE_removeoperstmt); + try { + this.state = 5666; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,294,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5654; + this.match(PostgreSQLParser.DROP); + this.state = 5655; + this.match(PostgreSQLParser.OPERATOR); + this.state = 5656; + this.operator_with_argtypes_list(); + this.state = 5657; + this.opt_drop_behavior(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5659; + this.match(PostgreSQLParser.DROP); + this.state = 5660; + this.match(PostgreSQLParser.OPERATOR); + this.state = 5661; + this.match(PostgreSQLParser.IF_P); + this.state = 5662; + this.match(PostgreSQLParser.EXISTS); + this.state = 5663; + this.operator_with_argtypes_list(); + this.state = 5664; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Oper_argtypesContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_oper_argtypes; + return this; +} + +Oper_argtypesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Oper_argtypesContext.prototype.constructor = Oper_argtypesContext; + +Oper_argtypesContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Oper_argtypesContext.prototype.typename = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TypenameContext); + } else { + return this.getTypedRuleContext(TypenameContext,i); + } +}; + +Oper_argtypesContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Oper_argtypesContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +Oper_argtypesContext.prototype.NONE = function() { + return this.getToken(PostgreSQLParser.NONE, 0); +}; + +Oper_argtypesContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOper_argtypes(this); + } +}; + +Oper_argtypesContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOper_argtypes(this); + } +}; + +Oper_argtypesContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOper_argtypes(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Oper_argtypesContext = Oper_argtypesContext; + +PostgreSQLParser.prototype.oper_argtypes = function() { + + var localctx = new Oper_argtypesContext(this, this._ctx, this.state); + this.enterRule(localctx, 682, PostgreSQLParser.RULE_oper_argtypes); + try { + this.state = 5690; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,295,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5668; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5669; + this.typename(); + this.state = 5670; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5672; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5673; + this.typename(); + this.state = 5674; + this.match(PostgreSQLParser.COMMA); + this.state = 5675; + this.typename(); + this.state = 5676; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5678; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5679; + this.match(PostgreSQLParser.NONE); + this.state = 5680; + this.match(PostgreSQLParser.COMMA); + this.state = 5681; + this.typename(); + this.state = 5682; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 5684; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5685; + this.typename(); + this.state = 5686; + this.match(PostgreSQLParser.COMMA); + this.state = 5687; + this.match(PostgreSQLParser.NONE); + this.state = 5688; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Any_operatorContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_any_operator; + return this; +} + +Any_operatorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Any_operatorContext.prototype.constructor = Any_operatorContext; + +Any_operatorContext.prototype.all_op = function() { + return this.getTypedRuleContext(All_opContext,0); +}; + +Any_operatorContext.prototype.colid = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(ColidContext); + } else { + return this.getTypedRuleContext(ColidContext,i); + } +}; + +Any_operatorContext.prototype.DOT = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.DOT); + } else { + return this.getToken(PostgreSQLParser.DOT, i); + } +}; + + +Any_operatorContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAny_operator(this); + } +}; + +Any_operatorContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAny_operator(this); + } +}; + +Any_operatorContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAny_operator(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Any_operatorContext = Any_operatorContext; + +PostgreSQLParser.prototype.any_operator = function() { + + var localctx = new Any_operatorContext(this, this._ctx, this.state); + this.enterRule(localctx, 684, PostgreSQLParser.RULE_any_operator); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5697; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(((((_la - 33)) & ~0x1f) == 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.AND - 33)) | (1 << (PostgreSQLParser.ARRAY - 33)) | (1 << (PostgreSQLParser.COLLATE - 33)) | (1 << (PostgreSQLParser.COLUMN - 33)) | (1 << (PostgreSQLParser.CONSTRAINT - 33)) | (1 << (PostgreSQLParser.DEFAULT - 33)) | (1 << (PostgreSQLParser.DO - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1f) == 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.TABLE - 92)) | (1 << (PostgreSQLParser.IS - 92)) | (1 << (PostgreSQLParser.OUTER_P - 92)))) !== 0) || ((((_la - 124)) & ~0x1f) == 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.OVER - 124)) | (1 << (PostgreSQLParser.ABORT_P - 124)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 124)) | (1 << (PostgreSQLParser.ACCESS - 124)) | (1 << (PostgreSQLParser.ACTION - 124)) | (1 << (PostgreSQLParser.ADD_P - 124)) | (1 << (PostgreSQLParser.ADMIN - 124)) | (1 << (PostgreSQLParser.AFTER - 124)) | (1 << (PostgreSQLParser.AGGREGATE - 124)) | (1 << (PostgreSQLParser.ALSO - 124)) | (1 << (PostgreSQLParser.ALTER - 124)) | (1 << (PostgreSQLParser.ALWAYS - 124)) | (1 << (PostgreSQLParser.ASSERTION - 124)) | (1 << (PostgreSQLParser.ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.AT - 124)) | (1 << (PostgreSQLParser.ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.BACKWARD - 124)) | (1 << (PostgreSQLParser.BEFORE - 124)) | (1 << (PostgreSQLParser.BEGIN_P - 124)) | (1 << (PostgreSQLParser.BY - 124)) | (1 << (PostgreSQLParser.CACHE - 124)) | (1 << (PostgreSQLParser.CALLED - 124)) | (1 << (PostgreSQLParser.CASCADE - 124)) | (1 << (PostgreSQLParser.CASCADED - 124)) | (1 << (PostgreSQLParser.CATALOG - 124)) | (1 << (PostgreSQLParser.CHAIN - 124)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1f) == 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.CLASS - 156)) | (1 << (PostgreSQLParser.CLOSE - 156)) | (1 << (PostgreSQLParser.CLUSTER - 156)) | (1 << (PostgreSQLParser.COMMENT - 156)) | (1 << (PostgreSQLParser.COMMENTS - 156)) | (1 << (PostgreSQLParser.COMMIT - 156)) | (1 << (PostgreSQLParser.COMMITTED - 156)) | (1 << (PostgreSQLParser.CONFIGURATION - 156)) | (1 << (PostgreSQLParser.CONNECTION - 156)) | (1 << (PostgreSQLParser.CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.CONTENT_P - 156)) | (1 << (PostgreSQLParser.CONTINUE_P - 156)) | (1 << (PostgreSQLParser.CONVERSION_P - 156)) | (1 << (PostgreSQLParser.COPY - 156)) | (1 << (PostgreSQLParser.COST - 156)) | (1 << (PostgreSQLParser.CSV - 156)) | (1 << (PostgreSQLParser.CURSOR - 156)) | (1 << (PostgreSQLParser.CYCLE - 156)) | (1 << (PostgreSQLParser.DATA_P - 156)) | (1 << (PostgreSQLParser.DATABASE - 156)) | (1 << (PostgreSQLParser.DAY_P - 156)) | (1 << (PostgreSQLParser.DEALLOCATE - 156)) | (1 << (PostgreSQLParser.DECLARE - 156)) | (1 << (PostgreSQLParser.DEFAULTS - 156)) | (1 << (PostgreSQLParser.DEFERRED - 156)) | (1 << (PostgreSQLParser.DEFINER - 156)) | (1 << (PostgreSQLParser.DELETE_P - 156)) | (1 << (PostgreSQLParser.DELIMITER - 156)) | (1 << (PostgreSQLParser.DELIMITERS - 156)) | (1 << (PostgreSQLParser.DICTIONARY - 156)) | (1 << (PostgreSQLParser.DISABLE_P - 156)) | (1 << (PostgreSQLParser.DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1f) == 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.DOCUMENT_P - 188)) | (1 << (PostgreSQLParser.DOMAIN_P - 188)) | (1 << (PostgreSQLParser.DOUBLE_P - 188)) | (1 << (PostgreSQLParser.DROP - 188)) | (1 << (PostgreSQLParser.EACH - 188)) | (1 << (PostgreSQLParser.ENABLE_P - 188)) | (1 << (PostgreSQLParser.ENCODING - 188)) | (1 << (PostgreSQLParser.ENCRYPTED - 188)) | (1 << (PostgreSQLParser.ENUM_P - 188)) | (1 << (PostgreSQLParser.ESCAPE - 188)) | (1 << (PostgreSQLParser.EVENT - 188)) | (1 << (PostgreSQLParser.EXCLUDE - 188)) | (1 << (PostgreSQLParser.EXCLUDING - 188)) | (1 << (PostgreSQLParser.EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.EXECUTE - 188)) | (1 << (PostgreSQLParser.EXPLAIN - 188)) | (1 << (PostgreSQLParser.EXTENSION - 188)) | (1 << (PostgreSQLParser.EXTERNAL - 188)) | (1 << (PostgreSQLParser.FAMILY - 188)) | (1 << (PostgreSQLParser.FIRST_P - 188)) | (1 << (PostgreSQLParser.FOLLOWING - 188)) | (1 << (PostgreSQLParser.FORCE - 188)) | (1 << (PostgreSQLParser.FORWARD - 188)) | (1 << (PostgreSQLParser.FUNCTION - 188)) | (1 << (PostgreSQLParser.FUNCTIONS - 188)) | (1 << (PostgreSQLParser.GLOBAL - 188)) | (1 << (PostgreSQLParser.GRANTED - 188)) | (1 << (PostgreSQLParser.HANDLER - 188)) | (1 << (PostgreSQLParser.HEADER_P - 188)) | (1 << (PostgreSQLParser.HOLD - 188)) | (1 << (PostgreSQLParser.HOUR_P - 188)) | (1 << (PostgreSQLParser.IDENTITY_P - 188)))) !== 0) || ((((_la - 220)) & ~0x1f) == 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.IF_P - 220)) | (1 << (PostgreSQLParser.IMMEDIATE - 220)) | (1 << (PostgreSQLParser.IMMUTABLE - 220)) | (1 << (PostgreSQLParser.IMPLICIT_P - 220)) | (1 << (PostgreSQLParser.INCLUDING - 220)) | (1 << (PostgreSQLParser.INCREMENT - 220)) | (1 << (PostgreSQLParser.INDEX - 220)) | (1 << (PostgreSQLParser.INDEXES - 220)) | (1 << (PostgreSQLParser.INHERIT - 220)) | (1 << (PostgreSQLParser.INHERITS - 220)) | (1 << (PostgreSQLParser.INLINE_P - 220)) | (1 << (PostgreSQLParser.INSENSITIVE - 220)) | (1 << (PostgreSQLParser.INSERT - 220)) | (1 << (PostgreSQLParser.INSTEAD - 220)) | (1 << (PostgreSQLParser.INVOKER - 220)) | (1 << (PostgreSQLParser.ISOLATION - 220)) | (1 << (PostgreSQLParser.KEY - 220)) | (1 << (PostgreSQLParser.LABEL - 220)) | (1 << (PostgreSQLParser.LANGUAGE - 220)) | (1 << (PostgreSQLParser.LARGE_P - 220)) | (1 << (PostgreSQLParser.LAST_P - 220)) | (1 << (PostgreSQLParser.LEAKPROOF - 220)) | (1 << (PostgreSQLParser.LEVEL - 220)) | (1 << (PostgreSQLParser.LISTEN - 220)) | (1 << (PostgreSQLParser.LOAD - 220)) | (1 << (PostgreSQLParser.LOCAL - 220)) | (1 << (PostgreSQLParser.LOCATION - 220)) | (1 << (PostgreSQLParser.LOCK_P - 220)) | (1 << (PostgreSQLParser.MAPPING - 220)) | (1 << (PostgreSQLParser.MATCH - 220)) | (1 << (PostgreSQLParser.MATERIALIZED - 220)) | (1 << (PostgreSQLParser.MAXVALUE - 220)))) !== 0) || ((((_la - 252)) & ~0x1f) == 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.MINUTE_P - 252)) | (1 << (PostgreSQLParser.MINVALUE - 252)) | (1 << (PostgreSQLParser.MODE - 252)) | (1 << (PostgreSQLParser.MONTH_P - 252)) | (1 << (PostgreSQLParser.MOVE - 252)) | (1 << (PostgreSQLParser.NAME_P - 252)) | (1 << (PostgreSQLParser.NAMES - 252)) | (1 << (PostgreSQLParser.NEXT - 252)) | (1 << (PostgreSQLParser.NO - 252)) | (1 << (PostgreSQLParser.NOTHING - 252)) | (1 << (PostgreSQLParser.NOTIFY - 252)) | (1 << (PostgreSQLParser.NOWAIT - 252)) | (1 << (PostgreSQLParser.NULLS_P - 252)) | (1 << (PostgreSQLParser.OBJECT_P - 252)) | (1 << (PostgreSQLParser.OF - 252)) | (1 << (PostgreSQLParser.OFF - 252)) | (1 << (PostgreSQLParser.OIDS - 252)) | (1 << (PostgreSQLParser.OPERATOR - 252)) | (1 << (PostgreSQLParser.OPTION - 252)) | (1 << (PostgreSQLParser.OPTIONS - 252)) | (1 << (PostgreSQLParser.OWNED - 252)) | (1 << (PostgreSQLParser.OWNER - 252)) | (1 << (PostgreSQLParser.PARSER - 252)) | (1 << (PostgreSQLParser.PARTIAL - 252)) | (1 << (PostgreSQLParser.PARTITION - 252)) | (1 << (PostgreSQLParser.PASSING - 252)) | (1 << (PostgreSQLParser.PASSWORD - 252)) | (1 << (PostgreSQLParser.PLANS - 252)) | (1 << (PostgreSQLParser.PRECEDING - 252)) | (1 << (PostgreSQLParser.PREPARE - 252)) | (1 << (PostgreSQLParser.PREPARED - 252)) | (1 << (PostgreSQLParser.PRESERVE - 252)))) !== 0) || ((((_la - 284)) & ~0x1f) == 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.PRIOR - 284)) | (1 << (PostgreSQLParser.PRIVILEGES - 284)) | (1 << (PostgreSQLParser.PROCEDURAL - 284)) | (1 << (PostgreSQLParser.PROCEDURE - 284)) | (1 << (PostgreSQLParser.PROGRAM - 284)) | (1 << (PostgreSQLParser.QUOTE - 284)) | (1 << (PostgreSQLParser.RANGE - 284)) | (1 << (PostgreSQLParser.READ - 284)) | (1 << (PostgreSQLParser.REASSIGN - 284)) | (1 << (PostgreSQLParser.RECHECK - 284)) | (1 << (PostgreSQLParser.RECURSIVE - 284)) | (1 << (PostgreSQLParser.REF - 284)) | (1 << (PostgreSQLParser.REFRESH - 284)) | (1 << (PostgreSQLParser.REINDEX - 284)) | (1 << (PostgreSQLParser.RELATIVE_P - 284)) | (1 << (PostgreSQLParser.RELEASE - 284)) | (1 << (PostgreSQLParser.RENAME - 284)) | (1 << (PostgreSQLParser.REPEATABLE - 284)) | (1 << (PostgreSQLParser.REPLACE - 284)) | (1 << (PostgreSQLParser.REPLICA - 284)) | (1 << (PostgreSQLParser.RESET - 284)) | (1 << (PostgreSQLParser.RESTART - 284)) | (1 << (PostgreSQLParser.RESTRICT - 284)) | (1 << (PostgreSQLParser.RETURNS - 284)) | (1 << (PostgreSQLParser.REVOKE - 284)) | (1 << (PostgreSQLParser.ROLE - 284)) | (1 << (PostgreSQLParser.ROLLBACK - 284)) | (1 << (PostgreSQLParser.ROWS - 284)) | (1 << (PostgreSQLParser.RULE - 284)) | (1 << (PostgreSQLParser.SAVEPOINT - 284)) | (1 << (PostgreSQLParser.SCHEMA - 284)) | (1 << (PostgreSQLParser.SCROLL - 284)))) !== 0) || ((((_la - 316)) & ~0x1f) == 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.SEARCH - 316)) | (1 << (PostgreSQLParser.SECOND_P - 316)) | (1 << (PostgreSQLParser.SECURITY - 316)) | (1 << (PostgreSQLParser.SEQUENCE - 316)) | (1 << (PostgreSQLParser.SEQUENCES - 316)) | (1 << (PostgreSQLParser.SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.SERVER - 316)) | (1 << (PostgreSQLParser.SESSION - 316)) | (1 << (PostgreSQLParser.SET - 316)) | (1 << (PostgreSQLParser.SHARE - 316)) | (1 << (PostgreSQLParser.SHOW - 316)) | (1 << (PostgreSQLParser.SIMPLE - 316)) | (1 << (PostgreSQLParser.SNAPSHOT - 316)) | (1 << (PostgreSQLParser.STABLE - 316)) | (1 << (PostgreSQLParser.STANDALONE_P - 316)) | (1 << (PostgreSQLParser.START - 316)) | (1 << (PostgreSQLParser.STATEMENT - 316)) | (1 << (PostgreSQLParser.STATISTICS - 316)) | (1 << (PostgreSQLParser.STDIN - 316)) | (1 << (PostgreSQLParser.STDOUT - 316)) | (1 << (PostgreSQLParser.STORAGE - 316)) | (1 << (PostgreSQLParser.STRICT_P - 316)) | (1 << (PostgreSQLParser.STRIP_P - 316)) | (1 << (PostgreSQLParser.SYSID - 316)) | (1 << (PostgreSQLParser.SYSTEM_P - 316)) | (1 << (PostgreSQLParser.TABLES - 316)) | (1 << (PostgreSQLParser.TABLESPACE - 316)) | (1 << (PostgreSQLParser.TEMP - 316)) | (1 << (PostgreSQLParser.TEMPLATE - 316)) | (1 << (PostgreSQLParser.TEMPORARY - 316)) | (1 << (PostgreSQLParser.TEXT_P - 316)) | (1 << (PostgreSQLParser.TRANSACTION - 316)))) !== 0) || ((((_la - 348)) & ~0x1f) == 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.TRIGGER - 348)) | (1 << (PostgreSQLParser.TRUNCATE - 348)) | (1 << (PostgreSQLParser.TRUSTED - 348)) | (1 << (PostgreSQLParser.TYPE_P - 348)) | (1 << (PostgreSQLParser.TYPES_P - 348)) | (1 << (PostgreSQLParser.UNBOUNDED - 348)) | (1 << (PostgreSQLParser.UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.UNKNOWN - 348)) | (1 << (PostgreSQLParser.UNLISTEN - 348)) | (1 << (PostgreSQLParser.UNLOGGED - 348)) | (1 << (PostgreSQLParser.UNTIL - 348)) | (1 << (PostgreSQLParser.UPDATE - 348)) | (1 << (PostgreSQLParser.VACUUM - 348)) | (1 << (PostgreSQLParser.VALID - 348)) | (1 << (PostgreSQLParser.VALIDATE - 348)) | (1 << (PostgreSQLParser.VALIDATOR - 348)) | (1 << (PostgreSQLParser.VARYING - 348)) | (1 << (PostgreSQLParser.VERSION_P - 348)) | (1 << (PostgreSQLParser.VIEW - 348)) | (1 << (PostgreSQLParser.VOLATILE - 348)) | (1 << (PostgreSQLParser.WHITESPACE_P - 348)) | (1 << (PostgreSQLParser.WITHOUT - 348)) | (1 << (PostgreSQLParser.WORK - 348)) | (1 << (PostgreSQLParser.WRAPPER - 348)) | (1 << (PostgreSQLParser.WRITE - 348)) | (1 << (PostgreSQLParser.XML_P - 348)) | (1 << (PostgreSQLParser.YEAR_P - 348)) | (1 << (PostgreSQLParser.YES_P - 348)) | (1 << (PostgreSQLParser.ZONE - 348)) | (1 << (PostgreSQLParser.BETWEEN - 348)) | (1 << (PostgreSQLParser.BIGINT - 348)))) !== 0) || ((((_la - 380)) & ~0x1f) == 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.BIT - 380)) | (1 << (PostgreSQLParser.BOOLEAN_P - 380)) | (1 << (PostgreSQLParser.CHAR_P - 380)) | (1 << (PostgreSQLParser.CHARACTER - 380)) | (1 << (PostgreSQLParser.COALESCE - 380)) | (1 << (PostgreSQLParser.DEC - 380)) | (1 << (PostgreSQLParser.DECIMAL_P - 380)) | (1 << (PostgreSQLParser.EXISTS - 380)) | (1 << (PostgreSQLParser.EXTRACT - 380)) | (1 << (PostgreSQLParser.FLOAT_P - 380)) | (1 << (PostgreSQLParser.GREATEST - 380)) | (1 << (PostgreSQLParser.INOUT - 380)) | (1 << (PostgreSQLParser.INT_P - 380)) | (1 << (PostgreSQLParser.INTEGER - 380)) | (1 << (PostgreSQLParser.INTERVAL - 380)) | (1 << (PostgreSQLParser.LEAST - 380)) | (1 << (PostgreSQLParser.NATIONAL - 380)) | (1 << (PostgreSQLParser.NCHAR - 380)) | (1 << (PostgreSQLParser.NONE - 380)) | (1 << (PostgreSQLParser.NULLIF - 380)) | (1 << (PostgreSQLParser.NUMERIC - 380)) | (1 << (PostgreSQLParser.OVERLAY - 380)) | (1 << (PostgreSQLParser.POSITION - 380)) | (1 << (PostgreSQLParser.PRECISION - 380)) | (1 << (PostgreSQLParser.REAL - 380)) | (1 << (PostgreSQLParser.ROW - 380)) | (1 << (PostgreSQLParser.SETOF - 380)) | (1 << (PostgreSQLParser.SMALLINT - 380)) | (1 << (PostgreSQLParser.SUBSTRING - 380)) | (1 << (PostgreSQLParser.TIME - 380)) | (1 << (PostgreSQLParser.TIMESTAMP - 380)) | (1 << (PostgreSQLParser.TREAT - 380)))) !== 0) || ((((_la - 412)) & ~0x1f) == 0 && ((1 << (_la - 412)) & ((1 << (PostgreSQLParser.TRIM - 412)) | (1 << (PostgreSQLParser.VALUES - 412)) | (1 << (PostgreSQLParser.VARCHAR - 412)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 412)) | (1 << (PostgreSQLParser.XMLCONCAT - 412)) | (1 << (PostgreSQLParser.XMLELEMENT - 412)) | (1 << (PostgreSQLParser.XMLEXISTS - 412)) | (1 << (PostgreSQLParser.XMLFOREST - 412)) | (1 << (PostgreSQLParser.XMLPARSE - 412)) | (1 << (PostgreSQLParser.XMLPI - 412)) | (1 << (PostgreSQLParser.XMLROOT - 412)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 412)) | (1 << (PostgreSQLParser.CALL - 412)) | (1 << (PostgreSQLParser.CURRENT_P - 412)) | (1 << (PostgreSQLParser.ATTACH - 412)) | (1 << (PostgreSQLParser.DETACH - 412)) | (1 << (PostgreSQLParser.EXPRESSION - 412)) | (1 << (PostgreSQLParser.GENERATED - 412)) | (1 << (PostgreSQLParser.LOGGED - 412)) | (1 << (PostgreSQLParser.STORED - 412)) | (1 << (PostgreSQLParser.INCLUDE - 412)) | (1 << (PostgreSQLParser.ROUTINE - 412)) | (1 << (PostgreSQLParser.TRANSFORM - 412)) | (1 << (PostgreSQLParser.IMPORT_P - 412)) | (1 << (PostgreSQLParser.POLICY - 412)) | (1 << (PostgreSQLParser.METHOD - 412)) | (1 << (PostgreSQLParser.REFERENCING - 412)) | (1 << (PostgreSQLParser.NEW - 412)) | (1 << (PostgreSQLParser.OLD - 412)) | (1 << (PostgreSQLParser.VALUE_P - 412)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 412)) | (1 << (PostgreSQLParser.PUBLICATION - 412)))) !== 0) || ((((_la - 444)) & ~0x1f) == 0 && ((1 << (_la - 444)) & ((1 << (PostgreSQLParser.OUT_P - 444)) | (1 << (PostgreSQLParser.ROUTINES - 444)) | (1 << (PostgreSQLParser.SCHEMAS - 444)) | (1 << (PostgreSQLParser.PROCEDURES - 444)) | (1 << (PostgreSQLParser.INPUT_P - 444)) | (1 << (PostgreSQLParser.SUPPORT - 444)) | (1 << (PostgreSQLParser.PARALLEL - 444)) | (1 << (PostgreSQLParser.SQL_P - 444)) | (1 << (PostgreSQLParser.DEPENDS - 444)) | (1 << (PostgreSQLParser.OVERRIDING - 444)) | (1 << (PostgreSQLParser.CONFLICT - 444)) | (1 << (PostgreSQLParser.SKIP_P - 444)) | (1 << (PostgreSQLParser.LOCKED - 444)) | (1 << (PostgreSQLParser.TIES - 444)) | (1 << (PostgreSQLParser.ROLLUP - 444)) | (1 << (PostgreSQLParser.CUBE - 444)) | (1 << (PostgreSQLParser.GROUPING - 444)) | (1 << (PostgreSQLParser.SETS - 444)) | (1 << (PostgreSQLParser.ORDINALITY - 444)) | (1 << (PostgreSQLParser.XMLTABLE - 444)) | (1 << (PostgreSQLParser.COLUMNS - 444)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 444)) | (1 << (PostgreSQLParser.ROWTYPE - 444)) | (1 << (PostgreSQLParser.NORMALIZED - 444)) | (1 << (PostgreSQLParser.WITHIN - 444)) | (1 << (PostgreSQLParser.FILTER - 444)) | (1 << (PostgreSQLParser.GROUPS - 444)) | (1 << (PostgreSQLParser.OTHERS - 444)) | (1 << (PostgreSQLParser.NFC - 444)) | (1 << (PostgreSQLParser.NFD - 444)))) !== 0) || ((((_la - 476)) & ~0x1f) == 0 && ((1 << (_la - 476)) & ((1 << (PostgreSQLParser.NFKC - 476)) | (1 << (PostgreSQLParser.NFKD - 476)) | (1 << (PostgreSQLParser.UESCAPE - 476)) | (1 << (PostgreSQLParser.VIEWS - 476)) | (1 << (PostgreSQLParser.NORMALIZE - 476)) | (1 << (PostgreSQLParser.DUMP - 476)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 476)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 476)) | (1 << (PostgreSQLParser.ERROR - 476)) | (1 << (PostgreSQLParser.USE_VARIABLE - 476)) | (1 << (PostgreSQLParser.USE_COLUMN - 476)) | (1 << (PostgreSQLParser.ALIAS - 476)) | (1 << (PostgreSQLParser.CONSTANT - 476)) | (1 << (PostgreSQLParser.PERFORM - 476)) | (1 << (PostgreSQLParser.GET - 476)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 476)) | (1 << (PostgreSQLParser.STACKED - 476)) | (1 << (PostgreSQLParser.ELSIF - 476)) | (1 << (PostgreSQLParser.REVERSE - 476)) | (1 << (PostgreSQLParser.SLICE - 476)) | (1 << (PostgreSQLParser.EXIT - 476)) | (1 << (PostgreSQLParser.RETURN - 476)) | (1 << (PostgreSQLParser.QUERY - 476)) | (1 << (PostgreSQLParser.RAISE - 476)) | (1 << (PostgreSQLParser.SQLSTATE - 476)) | (1 << (PostgreSQLParser.DEBUG - 476)) | (1 << (PostgreSQLParser.LOG - 476)) | (1 << (PostgreSQLParser.INFO - 476)) | (1 << (PostgreSQLParser.NOTICE - 476)) | (1 << (PostgreSQLParser.WARNING - 476)))) !== 0) || ((((_la - 508)) & ~0x1f) == 0 && ((1 << (_la - 508)) & ((1 << (PostgreSQLParser.EXCEPTION - 508)) | (1 << (PostgreSQLParser.ASSERT - 508)) | (1 << (PostgreSQLParser.OPEN - 508)) | (1 << (PostgreSQLParser.Identifier - 508)) | (1 << (PostgreSQLParser.QuotedIdentifier - 508)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 508)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 508)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 508)))) !== 0)) { + this.state = 5692; + this.colid(); + this.state = 5693; + this.match(PostgreSQLParser.DOT); + this.state = 5699; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 5700; + this.all_op(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Operator_with_argtypes_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_operator_with_argtypes_list; + return this; +} + +Operator_with_argtypes_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Operator_with_argtypes_listContext.prototype.constructor = Operator_with_argtypes_listContext; + +Operator_with_argtypes_listContext.prototype.operator_with_argtypes = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Operator_with_argtypesContext); + } else { + return this.getTypedRuleContext(Operator_with_argtypesContext,i); + } +}; + +Operator_with_argtypes_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Operator_with_argtypes_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOperator_with_argtypes_list(this); + } +}; + +Operator_with_argtypes_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOperator_with_argtypes_list(this); + } +}; + +Operator_with_argtypes_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOperator_with_argtypes_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Operator_with_argtypes_listContext = Operator_with_argtypes_listContext; + +PostgreSQLParser.prototype.operator_with_argtypes_list = function() { + + var localctx = new Operator_with_argtypes_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 686, PostgreSQLParser.RULE_operator_with_argtypes_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5702; + this.operator_with_argtypes(); + this.state = 5707; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5703; + this.match(PostgreSQLParser.COMMA); + this.state = 5704; + this.operator_with_argtypes(); + this.state = 5709; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Operator_with_argtypesContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_operator_with_argtypes; + return this; +} + +Operator_with_argtypesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Operator_with_argtypesContext.prototype.constructor = Operator_with_argtypesContext; + +Operator_with_argtypesContext.prototype.any_operator = function() { + return this.getTypedRuleContext(Any_operatorContext,0); +}; + +Operator_with_argtypesContext.prototype.oper_argtypes = function() { + return this.getTypedRuleContext(Oper_argtypesContext,0); +}; + +Operator_with_argtypesContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOperator_with_argtypes(this); + } +}; + +Operator_with_argtypesContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOperator_with_argtypes(this); + } +}; + +Operator_with_argtypesContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOperator_with_argtypes(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Operator_with_argtypesContext = Operator_with_argtypesContext; + +PostgreSQLParser.prototype.operator_with_argtypes = function() { + + var localctx = new Operator_with_argtypesContext(this, this._ctx, this.state); + this.enterRule(localctx, 688, PostgreSQLParser.RULE_operator_with_argtypes); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5710; + this.any_operator(); + this.state = 5711; + this.oper_argtypes(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DostmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dostmt; + return this; +} + +DostmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DostmtContext.prototype.constructor = DostmtContext; + +DostmtContext.prototype.DO = function() { + return this.getToken(PostgreSQLParser.DO, 0); +}; + +DostmtContext.prototype.dostmt_opt_list = function() { + return this.getTypedRuleContext(Dostmt_opt_listContext,0); +}; + +DostmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDostmt(this); + } +}; + +DostmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDostmt(this); + } +}; + +DostmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDostmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DostmtContext = DostmtContext; + +PostgreSQLParser.prototype.dostmt = function() { + + var localctx = new DostmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 690, PostgreSQLParser.RULE_dostmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5713; + this.match(PostgreSQLParser.DO); + this.state = 5714; + this.dostmt_opt_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Dostmt_opt_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dostmt_opt_list; + return this; +} + +Dostmt_opt_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Dostmt_opt_listContext.prototype.constructor = Dostmt_opt_listContext; + +Dostmt_opt_listContext.prototype.dostmt_opt_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Dostmt_opt_itemContext); + } else { + return this.getTypedRuleContext(Dostmt_opt_itemContext,i); + } +}; + +Dostmt_opt_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDostmt_opt_list(this); + } +}; + +Dostmt_opt_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDostmt_opt_list(this); + } +}; + +Dostmt_opt_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDostmt_opt_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Dostmt_opt_listContext = Dostmt_opt_listContext; + +PostgreSQLParser.prototype.dostmt_opt_list = function() { + + var localctx = new Dostmt_opt_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 692, PostgreSQLParser.RULE_dostmt_opt_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5717; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + this.state = 5716; + this.dostmt_opt_item(); + this.state = 5719; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while(_la===PostgreSQLParser.LANGUAGE || ((((_la - 521)) & ~0x1f) == 0 && ((1 << (_la - 521)) & ((1 << (PostgreSQLParser.StringConstant - 521)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 521)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 521)) | (1 << (PostgreSQLParser.EscapeStringConstant - 521)))) !== 0)); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Dostmt_opt_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dostmt_opt_item; + return this; +} + +Dostmt_opt_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Dostmt_opt_itemContext.prototype.constructor = Dostmt_opt_itemContext; + +Dostmt_opt_itemContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Dostmt_opt_itemContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +Dostmt_opt_itemContext.prototype.nonreservedword_or_sconst = function() { + return this.getTypedRuleContext(Nonreservedword_or_sconstContext,0); +}; + +Dostmt_opt_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDostmt_opt_item(this); + } +}; + +Dostmt_opt_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDostmt_opt_item(this); + } +}; + +Dostmt_opt_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDostmt_opt_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Dostmt_opt_itemContext = Dostmt_opt_itemContext; + +PostgreSQLParser.prototype.dostmt_opt_item = function() { + + var localctx = new Dostmt_opt_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 694, PostgreSQLParser.RULE_dostmt_opt_item); + try { + this.state = 5724; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 5721; + this.sconst(); + break; + case PostgreSQLParser.LANGUAGE: + this.enterOuterAlt(localctx, 2); + this.state = 5722; + this.match(PostgreSQLParser.LANGUAGE); + this.state = 5723; + this.nonreservedword_or_sconst(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatecaststmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createcaststmt; + return this; +} + +CreatecaststmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatecaststmtContext.prototype.constructor = CreatecaststmtContext; + +CreatecaststmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatecaststmtContext.prototype.CAST = function() { + return this.getToken(PostgreSQLParser.CAST, 0); +}; + +CreatecaststmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CreatecaststmtContext.prototype.typename = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TypenameContext); + } else { + return this.getTypedRuleContext(TypenameContext,i); + } +}; + +CreatecaststmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +CreatecaststmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CreatecaststmtContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +CreatecaststmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +CreatecaststmtContext.prototype.function_with_argtypes = function() { + return this.getTypedRuleContext(Function_with_argtypesContext,0); +}; + +CreatecaststmtContext.prototype.cast_context = function() { + return this.getTypedRuleContext(Cast_contextContext,0); +}; + +CreatecaststmtContext.prototype.WITHOUT = function() { + return this.getToken(PostgreSQLParser.WITHOUT, 0); +}; + +CreatecaststmtContext.prototype.INOUT = function() { + return this.getToken(PostgreSQLParser.INOUT, 0); +}; + +CreatecaststmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatecaststmt(this); + } +}; + +CreatecaststmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatecaststmt(this); + } +}; + +CreatecaststmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatecaststmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatecaststmtContext = CreatecaststmtContext; + +PostgreSQLParser.prototype.createcaststmt = function() { + + var localctx = new CreatecaststmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 696, PostgreSQLParser.RULE_createcaststmt); + try { + this.state = 5760; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,300,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5726; + this.match(PostgreSQLParser.CREATE); + this.state = 5727; + this.match(PostgreSQLParser.CAST); + this.state = 5728; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5729; + this.typename(); + this.state = 5730; + this.match(PostgreSQLParser.AS); + this.state = 5731; + this.typename(); + this.state = 5732; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 5733; + this.match(PostgreSQLParser.WITH); + this.state = 5734; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5735; + this.function_with_argtypes(); + this.state = 5736; + this.cast_context(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5738; + this.match(PostgreSQLParser.CREATE); + this.state = 5739; + this.match(PostgreSQLParser.CAST); + this.state = 5740; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5741; + this.typename(); + this.state = 5742; + this.match(PostgreSQLParser.AS); + this.state = 5743; + this.typename(); + this.state = 5744; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 5745; + this.match(PostgreSQLParser.WITHOUT); + this.state = 5746; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5747; + this.cast_context(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5749; + this.match(PostgreSQLParser.CREATE); + this.state = 5750; + this.match(PostgreSQLParser.CAST); + this.state = 5751; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5752; + this.typename(); + this.state = 5753; + this.match(PostgreSQLParser.AS); + this.state = 5754; + this.typename(); + this.state = 5755; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 5756; + this.match(PostgreSQLParser.WITH); + this.state = 5757; + this.match(PostgreSQLParser.INOUT); + this.state = 5758; + this.cast_context(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Cast_contextContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_cast_context; + return this; +} + +Cast_contextContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Cast_contextContext.prototype.constructor = Cast_contextContext; + +Cast_contextContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Cast_contextContext.prototype.IMPLICIT_P = function() { + return this.getToken(PostgreSQLParser.IMPLICIT_P, 0); +}; + +Cast_contextContext.prototype.ASSIGNMENT = function() { + return this.getToken(PostgreSQLParser.ASSIGNMENT, 0); +}; + +Cast_contextContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCast_context(this); + } +}; + +Cast_contextContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCast_context(this); + } +}; + +Cast_contextContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCast_context(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Cast_contextContext = Cast_contextContext; + +PostgreSQLParser.prototype.cast_context = function() { + + var localctx = new Cast_contextContext(this, this._ctx, this.state); + this.enterRule(localctx, 698, PostgreSQLParser.RULE_cast_context); + try { + this.state = 5767; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,301,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5762; + this.match(PostgreSQLParser.AS); + this.state = 5763; + this.match(PostgreSQLParser.IMPLICIT_P); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5764; + this.match(PostgreSQLParser.AS); + this.state = 5765; + this.match(PostgreSQLParser.ASSIGNMENT); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DropcaststmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dropcaststmt; + return this; +} + +DropcaststmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DropcaststmtContext.prototype.constructor = DropcaststmtContext; + +DropcaststmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DropcaststmtContext.prototype.CAST = function() { + return this.getToken(PostgreSQLParser.CAST, 0); +}; + +DropcaststmtContext.prototype.opt_if_exists = function() { + return this.getTypedRuleContext(Opt_if_existsContext,0); +}; + +DropcaststmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +DropcaststmtContext.prototype.typename = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TypenameContext); + } else { + return this.getTypedRuleContext(TypenameContext,i); + } +}; + +DropcaststmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +DropcaststmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +DropcaststmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +DropcaststmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDropcaststmt(this); + } +}; + +DropcaststmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDropcaststmt(this); + } +}; + +DropcaststmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDropcaststmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DropcaststmtContext = DropcaststmtContext; + +PostgreSQLParser.prototype.dropcaststmt = function() { + + var localctx = new DropcaststmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 700, PostgreSQLParser.RULE_dropcaststmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5769; + this.match(PostgreSQLParser.DROP); + this.state = 5770; + this.match(PostgreSQLParser.CAST); + this.state = 5771; + this.opt_if_exists(); + this.state = 5772; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5773; + this.typename(); + this.state = 5774; + this.match(PostgreSQLParser.AS); + this.state = 5775; + this.typename(); + this.state = 5776; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 5777; + this.opt_drop_behavior(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_if_existsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_if_exists; + return this; +} + +Opt_if_existsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_if_existsContext.prototype.constructor = Opt_if_existsContext; + +Opt_if_existsContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +Opt_if_existsContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +Opt_if_existsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_if_exists(this); + } +}; + +Opt_if_existsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_if_exists(this); + } +}; + +Opt_if_existsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_if_exists(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_if_existsContext = Opt_if_existsContext; + +PostgreSQLParser.prototype.opt_if_exists = function() { + + var localctx = new Opt_if_existsContext(this, this._ctx, this.state); + this.enterRule(localctx, 702, PostgreSQLParser.RULE_opt_if_exists); + try { + this.state = 5782; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.IF_P: + this.enterOuterAlt(localctx, 1); + this.state = 5779; + this.match(PostgreSQLParser.IF_P); + this.state = 5780; + this.match(PostgreSQLParser.EXISTS); + break; + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.FOR: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatetransformstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createtransformstmt; + return this; +} + +CreatetransformstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatetransformstmtContext.prototype.constructor = CreatetransformstmtContext; + +CreatetransformstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatetransformstmtContext.prototype.opt_or_replace = function() { + return this.getTypedRuleContext(Opt_or_replaceContext,0); +}; + +CreatetransformstmtContext.prototype.TRANSFORM = function() { + return this.getToken(PostgreSQLParser.TRANSFORM, 0); +}; + +CreatetransformstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +CreatetransformstmtContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +CreatetransformstmtContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +CreatetransformstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreatetransformstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CreatetransformstmtContext.prototype.transform_element_list = function() { + return this.getTypedRuleContext(Transform_element_listContext,0); +}; + +CreatetransformstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CreatetransformstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatetransformstmt(this); + } +}; + +CreatetransformstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatetransformstmt(this); + } +}; + +CreatetransformstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatetransformstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatetransformstmtContext = CreatetransformstmtContext; + +PostgreSQLParser.prototype.createtransformstmt = function() { + + var localctx = new CreatetransformstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 704, PostgreSQLParser.RULE_createtransformstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5784; + this.match(PostgreSQLParser.CREATE); + this.state = 5785; + this.opt_or_replace(); + this.state = 5786; + this.match(PostgreSQLParser.TRANSFORM); + this.state = 5787; + this.match(PostgreSQLParser.FOR); + this.state = 5788; + this.typename(); + this.state = 5789; + this.match(PostgreSQLParser.LANGUAGE); + this.state = 5790; + this.name(); + this.state = 5791; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5792; + this.transform_element_list(); + this.state = 5793; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Transform_element_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_transform_element_list; + return this; +} + +Transform_element_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Transform_element_listContext.prototype.constructor = Transform_element_listContext; + +Transform_element_listContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Transform_element_listContext.prototype.SQL_P = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.SQL_P); + } else { + return this.getToken(PostgreSQLParser.SQL_P, i); + } +}; + + +Transform_element_listContext.prototype.WITH = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.WITH); + } else { + return this.getToken(PostgreSQLParser.WITH, i); + } +}; + + +Transform_element_listContext.prototype.FUNCTION = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.FUNCTION); + } else { + return this.getToken(PostgreSQLParser.FUNCTION, i); + } +}; + + +Transform_element_listContext.prototype.function_with_argtypes = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Function_with_argtypesContext); + } else { + return this.getTypedRuleContext(Function_with_argtypesContext,i); + } +}; + +Transform_element_listContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +Transform_element_listContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +Transform_element_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTransform_element_list(this); + } +}; + +Transform_element_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTransform_element_list(this); + } +}; + +Transform_element_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTransform_element_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Transform_element_listContext = Transform_element_listContext; + +PostgreSQLParser.prototype.transform_element_list = function() { + + var localctx = new Transform_element_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 706, PostgreSQLParser.RULE_transform_element_list); + try { + this.state = 5829; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,303,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5795; + this.match(PostgreSQLParser.FROM); + this.state = 5796; + this.match(PostgreSQLParser.SQL_P); + this.state = 5797; + this.match(PostgreSQLParser.WITH); + this.state = 5798; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5799; + this.function_with_argtypes(); + this.state = 5800; + this.match(PostgreSQLParser.COMMA); + this.state = 5801; + this.match(PostgreSQLParser.TO); + this.state = 5802; + this.match(PostgreSQLParser.SQL_P); + this.state = 5803; + this.match(PostgreSQLParser.WITH); + this.state = 5804; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5805; + this.function_with_argtypes(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5807; + this.match(PostgreSQLParser.TO); + this.state = 5808; + this.match(PostgreSQLParser.SQL_P); + this.state = 5809; + this.match(PostgreSQLParser.WITH); + this.state = 5810; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5811; + this.function_with_argtypes(); + this.state = 5812; + this.match(PostgreSQLParser.COMMA); + this.state = 5813; + this.match(PostgreSQLParser.FROM); + this.state = 5814; + this.match(PostgreSQLParser.SQL_P); + this.state = 5815; + this.match(PostgreSQLParser.WITH); + this.state = 5816; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5817; + this.function_with_argtypes(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5819; + this.match(PostgreSQLParser.FROM); + this.state = 5820; + this.match(PostgreSQLParser.SQL_P); + this.state = 5821; + this.match(PostgreSQLParser.WITH); + this.state = 5822; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5823; + this.function_with_argtypes(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 5824; + this.match(PostgreSQLParser.TO); + this.state = 5825; + this.match(PostgreSQLParser.SQL_P); + this.state = 5826; + this.match(PostgreSQLParser.WITH); + this.state = 5827; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5828; + this.function_with_argtypes(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DroptransformstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_droptransformstmt; + return this; +} + +DroptransformstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DroptransformstmtContext.prototype.constructor = DroptransformstmtContext; + +DroptransformstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DroptransformstmtContext.prototype.TRANSFORM = function() { + return this.getToken(PostgreSQLParser.TRANSFORM, 0); +}; + +DroptransformstmtContext.prototype.opt_if_exists = function() { + return this.getTypedRuleContext(Opt_if_existsContext,0); +}; + +DroptransformstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +DroptransformstmtContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +DroptransformstmtContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +DroptransformstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +DroptransformstmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +DroptransformstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDroptransformstmt(this); + } +}; + +DroptransformstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDroptransformstmt(this); + } +}; + +DroptransformstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDroptransformstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DroptransformstmtContext = DroptransformstmtContext; + +PostgreSQLParser.prototype.droptransformstmt = function() { + + var localctx = new DroptransformstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 708, PostgreSQLParser.RULE_droptransformstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5831; + this.match(PostgreSQLParser.DROP); + this.state = 5832; + this.match(PostgreSQLParser.TRANSFORM); + this.state = 5833; + this.opt_if_exists(); + this.state = 5834; + this.match(PostgreSQLParser.FOR); + this.state = 5835; + this.typename(); + this.state = 5836; + this.match(PostgreSQLParser.LANGUAGE); + this.state = 5837; + this.name(); + this.state = 5838; + this.opt_drop_behavior(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ReindexstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reindexstmt; + return this; +} + +ReindexstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ReindexstmtContext.prototype.constructor = ReindexstmtContext; + +ReindexstmtContext.prototype.REINDEX = function() { + return this.getToken(PostgreSQLParser.REINDEX, 0); +}; + +ReindexstmtContext.prototype.reindex_target_type = function() { + return this.getTypedRuleContext(Reindex_target_typeContext,0); +}; + +ReindexstmtContext.prototype.opt_concurrently = function() { + return this.getTypedRuleContext(Opt_concurrentlyContext,0); +}; + +ReindexstmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +ReindexstmtContext.prototype.reindex_target_multitable = function() { + return this.getTypedRuleContext(Reindex_target_multitableContext,0); +}; + +ReindexstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +ReindexstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +ReindexstmtContext.prototype.reindex_option_list = function() { + return this.getTypedRuleContext(Reindex_option_listContext,0); +}; + +ReindexstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +ReindexstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReindexstmt(this); + } +}; + +ReindexstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReindexstmt(this); + } +}; + +ReindexstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReindexstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ReindexstmtContext = ReindexstmtContext; + +PostgreSQLParser.prototype.reindexstmt = function() { + + var localctx = new ReindexstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 710, PostgreSQLParser.RULE_reindexstmt); + try { + this.state = 5866; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,304,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5840; + this.match(PostgreSQLParser.REINDEX); + this.state = 5841; + this.reindex_target_type(); + this.state = 5842; + this.opt_concurrently(); + this.state = 5843; + this.qualified_name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5845; + this.match(PostgreSQLParser.REINDEX); + this.state = 5846; + this.reindex_target_multitable(); + this.state = 5847; + this.opt_concurrently(); + this.state = 5848; + this.name(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5850; + this.match(PostgreSQLParser.REINDEX); + this.state = 5851; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5852; + this.reindex_option_list(); + this.state = 5853; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 5854; + this.reindex_target_type(); + this.state = 5855; + this.opt_concurrently(); + this.state = 5856; + this.qualified_name(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 5858; + this.match(PostgreSQLParser.REINDEX); + this.state = 5859; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5860; + this.reindex_option_list(); + this.state = 5861; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 5862; + this.reindex_target_multitable(); + this.state = 5863; + this.opt_concurrently(); + this.state = 5864; + this.name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Reindex_target_typeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reindex_target_type; + return this; +} + +Reindex_target_typeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Reindex_target_typeContext.prototype.constructor = Reindex_target_typeContext; + +Reindex_target_typeContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +Reindex_target_typeContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +Reindex_target_typeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReindex_target_type(this); + } +}; + +Reindex_target_typeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReindex_target_type(this); + } +}; + +Reindex_target_typeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReindex_target_type(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Reindex_target_typeContext = Reindex_target_typeContext; + +PostgreSQLParser.prototype.reindex_target_type = function() { + + var localctx = new Reindex_target_typeContext(this, this._ctx, this.state); + this.enterRule(localctx, 712, PostgreSQLParser.RULE_reindex_target_type); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5868; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.TABLE || _la===PostgreSQLParser.INDEX)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Reindex_target_multitableContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reindex_target_multitable; + return this; +} + +Reindex_target_multitableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Reindex_target_multitableContext.prototype.constructor = Reindex_target_multitableContext; + +Reindex_target_multitableContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +Reindex_target_multitableContext.prototype.SYSTEM_P = function() { + return this.getToken(PostgreSQLParser.SYSTEM_P, 0); +}; + +Reindex_target_multitableContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +Reindex_target_multitableContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReindex_target_multitable(this); + } +}; + +Reindex_target_multitableContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReindex_target_multitable(this); + } +}; + +Reindex_target_multitableContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReindex_target_multitable(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Reindex_target_multitableContext = Reindex_target_multitableContext; + +PostgreSQLParser.prototype.reindex_target_multitable = function() { + + var localctx = new Reindex_target_multitableContext(this, this._ctx, this.state); + this.enterRule(localctx, 714, PostgreSQLParser.RULE_reindex_target_multitable); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5870; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.DATABASE || _la===PostgreSQLParser.SCHEMA || _la===PostgreSQLParser.SYSTEM_P)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Reindex_option_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reindex_option_list; + return this; +} + +Reindex_option_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Reindex_option_listContext.prototype.constructor = Reindex_option_listContext; + +Reindex_option_listContext.prototype.reindex_option_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Reindex_option_elemContext); + } else { + return this.getTypedRuleContext(Reindex_option_elemContext,i); + } +}; + +Reindex_option_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Reindex_option_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReindex_option_list(this); + } +}; + +Reindex_option_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReindex_option_list(this); + } +}; + +Reindex_option_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReindex_option_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Reindex_option_listContext = Reindex_option_listContext; + +PostgreSQLParser.prototype.reindex_option_list = function() { + + var localctx = new Reindex_option_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 716, PostgreSQLParser.RULE_reindex_option_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 5872; + this.reindex_option_elem(); + this.state = 5877; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 5873; + this.match(PostgreSQLParser.COMMA); + this.state = 5874; + this.reindex_option_elem(); + this.state = 5879; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Reindex_option_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reindex_option_elem; + return this; +} + +Reindex_option_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Reindex_option_elemContext.prototype.constructor = Reindex_option_elemContext; + +Reindex_option_elemContext.prototype.VERBOSE = function() { + return this.getToken(PostgreSQLParser.VERBOSE, 0); +}; + +Reindex_option_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReindex_option_elem(this); + } +}; + +Reindex_option_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReindex_option_elem(this); + } +}; + +Reindex_option_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReindex_option_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Reindex_option_elemContext = Reindex_option_elemContext; + +PostgreSQLParser.prototype.reindex_option_elem = function() { + + var localctx = new Reindex_option_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 718, PostgreSQLParser.RULE_reindex_option_elem); + try { + this.enterOuterAlt(localctx, 1); + this.state = 5880; + this.match(PostgreSQLParser.VERBOSE); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltertblspcstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altertblspcstmt; + return this; +} + +AltertblspcstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltertblspcstmtContext.prototype.constructor = AltertblspcstmtContext; + +AltertblspcstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AltertblspcstmtContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +AltertblspcstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AltertblspcstmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AltertblspcstmtContext.prototype.reloptions = function() { + return this.getTypedRuleContext(ReloptionsContext,0); +}; + +AltertblspcstmtContext.prototype.RESET = function() { + return this.getToken(PostgreSQLParser.RESET, 0); +}; + +AltertblspcstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltertblspcstmt(this); + } +}; + +AltertblspcstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltertblspcstmt(this); + } +}; + +AltertblspcstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltertblspcstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltertblspcstmtContext = AltertblspcstmtContext; + +PostgreSQLParser.prototype.altertblspcstmt = function() { + + var localctx = new AltertblspcstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 720, PostgreSQLParser.RULE_altertblspcstmt); + try { + this.state = 5894; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,306,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5882; + this.match(PostgreSQLParser.ALTER); + this.state = 5883; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 5884; + this.name(); + this.state = 5885; + this.match(PostgreSQLParser.SET); + this.state = 5886; + this.reloptions(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5888; + this.match(PostgreSQLParser.ALTER); + this.state = 5889; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 5890; + this.name(); + this.state = 5891; + this.match(PostgreSQLParser.RESET); + this.state = 5892; + this.reloptions(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RenamestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_renamestmt; + return this; +} + +RenamestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RenamestmtContext.prototype.constructor = RenamestmtContext; + +RenamestmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +RenamestmtContext.prototype.AGGREGATE = function() { + return this.getToken(PostgreSQLParser.AGGREGATE, 0); +}; + +RenamestmtContext.prototype.aggregate_with_argtypes = function() { + return this.getTypedRuleContext(Aggregate_with_argtypesContext,0); +}; + +RenamestmtContext.prototype.RENAME = function() { + return this.getToken(PostgreSQLParser.RENAME, 0); +}; + +RenamestmtContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +RenamestmtContext.prototype.name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(NameContext); + } else { + return this.getTypedRuleContext(NameContext,i); + } +}; + +RenamestmtContext.prototype.COLLATION = function() { + return this.getToken(PostgreSQLParser.COLLATION, 0); +}; + +RenamestmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +RenamestmtContext.prototype.CONVERSION_P = function() { + return this.getToken(PostgreSQLParser.CONVERSION_P, 0); +}; + +RenamestmtContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +RenamestmtContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +RenamestmtContext.prototype.CONSTRAINT = function() { + return this.getToken(PostgreSQLParser.CONSTRAINT, 0); +}; + +RenamestmtContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +RenamestmtContext.prototype.DATA_P = function() { + return this.getToken(PostgreSQLParser.DATA_P, 0); +}; + +RenamestmtContext.prototype.WRAPPER = function() { + return this.getToken(PostgreSQLParser.WRAPPER, 0); +}; + +RenamestmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +RenamestmtContext.prototype.function_with_argtypes = function() { + return this.getTypedRuleContext(Function_with_argtypesContext,0); +}; + +RenamestmtContext.prototype.GROUP_P = function() { + return this.getToken(PostgreSQLParser.GROUP_P, 0); +}; + +RenamestmtContext.prototype.roleid = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(RoleidContext); + } else { + return this.getTypedRuleContext(RoleidContext,i); + } +}; + +RenamestmtContext.prototype.opt_procedural = function() { + return this.getTypedRuleContext(Opt_proceduralContext,0); +}; + +RenamestmtContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +RenamestmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +RenamestmtContext.prototype.CLASS = function() { + return this.getToken(PostgreSQLParser.CLASS, 0); +}; + +RenamestmtContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +RenamestmtContext.prototype.FAMILY = function() { + return this.getToken(PostgreSQLParser.FAMILY, 0); +}; + +RenamestmtContext.prototype.POLICY = function() { + return this.getToken(PostgreSQLParser.POLICY, 0); +}; + +RenamestmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +RenamestmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +RenamestmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +RenamestmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +RenamestmtContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +RenamestmtContext.prototype.PUBLICATION = function() { + return this.getToken(PostgreSQLParser.PUBLICATION, 0); +}; + +RenamestmtContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +RenamestmtContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +RenamestmtContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +RenamestmtContext.prototype.SUBSCRIPTION = function() { + return this.getToken(PostgreSQLParser.SUBSCRIPTION, 0); +}; + +RenamestmtContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +RenamestmtContext.prototype.relation_expr = function() { + return this.getTypedRuleContext(Relation_exprContext,0); +}; + +RenamestmtContext.prototype.SEQUENCE = function() { + return this.getToken(PostgreSQLParser.SEQUENCE, 0); +}; + +RenamestmtContext.prototype.VIEW = function() { + return this.getToken(PostgreSQLParser.VIEW, 0); +}; + +RenamestmtContext.prototype.MATERIALIZED = function() { + return this.getToken(PostgreSQLParser.MATERIALIZED, 0); +}; + +RenamestmtContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +RenamestmtContext.prototype.opt_column = function() { + return this.getTypedRuleContext(Opt_columnContext,0); +}; + +RenamestmtContext.prototype.RULE = function() { + return this.getToken(PostgreSQLParser.RULE, 0); +}; + +RenamestmtContext.prototype.TRIGGER = function() { + return this.getToken(PostgreSQLParser.TRIGGER, 0); +}; + +RenamestmtContext.prototype.EVENT = function() { + return this.getToken(PostgreSQLParser.EVENT, 0); +}; + +RenamestmtContext.prototype.ROLE = function() { + return this.getToken(PostgreSQLParser.ROLE, 0); +}; + +RenamestmtContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +RenamestmtContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +RenamestmtContext.prototype.STATISTICS = function() { + return this.getToken(PostgreSQLParser.STATISTICS, 0); +}; + +RenamestmtContext.prototype.TEXT_P = function() { + return this.getToken(PostgreSQLParser.TEXT_P, 0); +}; + +RenamestmtContext.prototype.SEARCH = function() { + return this.getToken(PostgreSQLParser.SEARCH, 0); +}; + +RenamestmtContext.prototype.PARSER = function() { + return this.getToken(PostgreSQLParser.PARSER, 0); +}; + +RenamestmtContext.prototype.DICTIONARY = function() { + return this.getToken(PostgreSQLParser.DICTIONARY, 0); +}; + +RenamestmtContext.prototype.TEMPLATE = function() { + return this.getToken(PostgreSQLParser.TEMPLATE, 0); +}; + +RenamestmtContext.prototype.CONFIGURATION = function() { + return this.getToken(PostgreSQLParser.CONFIGURATION, 0); +}; + +RenamestmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +RenamestmtContext.prototype.ATTRIBUTE = function() { + return this.getToken(PostgreSQLParser.ATTRIBUTE, 0); +}; + +RenamestmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +RenamestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRenamestmt(this); + } +}; + +RenamestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRenamestmt(this); + } +}; + +RenamestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRenamestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RenamestmtContext = RenamestmtContext; + +PostgreSQLParser.prototype.renamestmt = function() { + + var localctx = new RenamestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 722, PostgreSQLParser.RULE_renamestmt); + try { + this.state = 6364; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,307,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 5896; + this.match(PostgreSQLParser.ALTER); + this.state = 5897; + this.match(PostgreSQLParser.AGGREGATE); + this.state = 5898; + this.aggregate_with_argtypes(); + this.state = 5899; + this.match(PostgreSQLParser.RENAME); + this.state = 5900; + this.match(PostgreSQLParser.TO); + this.state = 5901; + this.name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 5903; + this.match(PostgreSQLParser.ALTER); + this.state = 5904; + this.match(PostgreSQLParser.COLLATION); + this.state = 5905; + this.any_name(); + this.state = 5906; + this.match(PostgreSQLParser.RENAME); + this.state = 5907; + this.match(PostgreSQLParser.TO); + this.state = 5908; + this.name(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 5910; + this.match(PostgreSQLParser.ALTER); + this.state = 5911; + this.match(PostgreSQLParser.CONVERSION_P); + this.state = 5912; + this.any_name(); + this.state = 5913; + this.match(PostgreSQLParser.RENAME); + this.state = 5914; + this.match(PostgreSQLParser.TO); + this.state = 5915; + this.name(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 5917; + this.match(PostgreSQLParser.ALTER); + this.state = 5918; + this.match(PostgreSQLParser.DATABASE); + this.state = 5919; + this.name(); + this.state = 5920; + this.match(PostgreSQLParser.RENAME); + this.state = 5921; + this.match(PostgreSQLParser.TO); + this.state = 5922; + this.name(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 5924; + this.match(PostgreSQLParser.ALTER); + this.state = 5925; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 5926; + this.any_name(); + this.state = 5927; + this.match(PostgreSQLParser.RENAME); + this.state = 5928; + this.match(PostgreSQLParser.TO); + this.state = 5929; + this.name(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 5931; + this.match(PostgreSQLParser.ALTER); + this.state = 5932; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 5933; + this.any_name(); + this.state = 5934; + this.match(PostgreSQLParser.RENAME); + this.state = 5935; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 5936; + this.name(); + this.state = 5937; + this.match(PostgreSQLParser.TO); + this.state = 5938; + this.name(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 5940; + this.match(PostgreSQLParser.ALTER); + this.state = 5941; + this.match(PostgreSQLParser.FOREIGN); + this.state = 5942; + this.match(PostgreSQLParser.DATA_P); + this.state = 5943; + this.match(PostgreSQLParser.WRAPPER); + this.state = 5944; + this.name(); + this.state = 5945; + this.match(PostgreSQLParser.RENAME); + this.state = 5946; + this.match(PostgreSQLParser.TO); + this.state = 5947; + this.name(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 5949; + this.match(PostgreSQLParser.ALTER); + this.state = 5950; + this.match(PostgreSQLParser.FUNCTION); + this.state = 5951; + this.function_with_argtypes(); + this.state = 5952; + this.match(PostgreSQLParser.RENAME); + this.state = 5953; + this.match(PostgreSQLParser.TO); + this.state = 5954; + this.name(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 5956; + this.match(PostgreSQLParser.ALTER); + this.state = 5957; + this.match(PostgreSQLParser.GROUP_P); + this.state = 5958; + this.roleid(); + this.state = 5959; + this.match(PostgreSQLParser.RENAME); + this.state = 5960; + this.match(PostgreSQLParser.TO); + this.state = 5961; + this.roleid(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 5963; + this.match(PostgreSQLParser.ALTER); + this.state = 5964; + this.opt_procedural(); + this.state = 5965; + this.match(PostgreSQLParser.LANGUAGE); + this.state = 5966; + this.name(); + this.state = 5967; + this.match(PostgreSQLParser.RENAME); + this.state = 5968; + this.match(PostgreSQLParser.TO); + this.state = 5969; + this.name(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 5971; + this.match(PostgreSQLParser.ALTER); + this.state = 5972; + this.match(PostgreSQLParser.OPERATOR); + this.state = 5973; + this.match(PostgreSQLParser.CLASS); + this.state = 5974; + this.any_name(); + this.state = 5975; + this.match(PostgreSQLParser.USING); + this.state = 5976; + this.name(); + this.state = 5977; + this.match(PostgreSQLParser.RENAME); + this.state = 5978; + this.match(PostgreSQLParser.TO); + this.state = 5979; + this.name(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 5981; + this.match(PostgreSQLParser.ALTER); + this.state = 5982; + this.match(PostgreSQLParser.OPERATOR); + this.state = 5983; + this.match(PostgreSQLParser.FAMILY); + this.state = 5984; + this.any_name(); + this.state = 5985; + this.match(PostgreSQLParser.USING); + this.state = 5986; + this.name(); + this.state = 5987; + this.match(PostgreSQLParser.RENAME); + this.state = 5988; + this.match(PostgreSQLParser.TO); + this.state = 5989; + this.name(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 5991; + this.match(PostgreSQLParser.ALTER); + this.state = 5992; + this.match(PostgreSQLParser.POLICY); + this.state = 5993; + this.name(); + this.state = 5994; + this.match(PostgreSQLParser.ON); + this.state = 5995; + this.qualified_name(); + this.state = 5996; + this.match(PostgreSQLParser.RENAME); + this.state = 5997; + this.match(PostgreSQLParser.TO); + this.state = 5998; + this.name(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 6000; + this.match(PostgreSQLParser.ALTER); + this.state = 6001; + this.match(PostgreSQLParser.POLICY); + this.state = 6002; + this.match(PostgreSQLParser.IF_P); + this.state = 6003; + this.match(PostgreSQLParser.EXISTS); + this.state = 6004; + this.name(); + this.state = 6005; + this.match(PostgreSQLParser.ON); + this.state = 6006; + this.qualified_name(); + this.state = 6007; + this.match(PostgreSQLParser.RENAME); + this.state = 6008; + this.match(PostgreSQLParser.TO); + this.state = 6009; + this.name(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 6011; + this.match(PostgreSQLParser.ALTER); + this.state = 6012; + this.match(PostgreSQLParser.PROCEDURE); + this.state = 6013; + this.function_with_argtypes(); + this.state = 6014; + this.match(PostgreSQLParser.RENAME); + this.state = 6015; + this.match(PostgreSQLParser.TO); + this.state = 6016; + this.name(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 6018; + this.match(PostgreSQLParser.ALTER); + this.state = 6019; + this.match(PostgreSQLParser.PUBLICATION); + this.state = 6020; + this.name(); + this.state = 6021; + this.match(PostgreSQLParser.RENAME); + this.state = 6022; + this.match(PostgreSQLParser.TO); + this.state = 6023; + this.name(); + break; + + case 17: + this.enterOuterAlt(localctx, 17); + this.state = 6025; + this.match(PostgreSQLParser.ALTER); + this.state = 6026; + this.match(PostgreSQLParser.ROUTINE); + this.state = 6027; + this.function_with_argtypes(); + this.state = 6028; + this.match(PostgreSQLParser.RENAME); + this.state = 6029; + this.match(PostgreSQLParser.TO); + this.state = 6030; + this.name(); + break; + + case 18: + this.enterOuterAlt(localctx, 18); + this.state = 6032; + this.match(PostgreSQLParser.ALTER); + this.state = 6033; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6034; + this.name(); + this.state = 6035; + this.match(PostgreSQLParser.RENAME); + this.state = 6036; + this.match(PostgreSQLParser.TO); + this.state = 6037; + this.name(); + break; + + case 19: + this.enterOuterAlt(localctx, 19); + this.state = 6039; + this.match(PostgreSQLParser.ALTER); + this.state = 6040; + this.match(PostgreSQLParser.SERVER); + this.state = 6041; + this.name(); + this.state = 6042; + this.match(PostgreSQLParser.RENAME); + this.state = 6043; + this.match(PostgreSQLParser.TO); + this.state = 6044; + this.name(); + break; + + case 20: + this.enterOuterAlt(localctx, 20); + this.state = 6046; + this.match(PostgreSQLParser.ALTER); + this.state = 6047; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6048; + this.name(); + this.state = 6049; + this.match(PostgreSQLParser.RENAME); + this.state = 6050; + this.match(PostgreSQLParser.TO); + this.state = 6051; + this.name(); + break; + + case 21: + this.enterOuterAlt(localctx, 21); + this.state = 6053; + this.match(PostgreSQLParser.ALTER); + this.state = 6054; + this.match(PostgreSQLParser.TABLE); + this.state = 6055; + this.relation_expr(); + this.state = 6056; + this.match(PostgreSQLParser.RENAME); + this.state = 6057; + this.match(PostgreSQLParser.TO); + this.state = 6058; + this.name(); + break; + + case 22: + this.enterOuterAlt(localctx, 22); + this.state = 6060; + this.match(PostgreSQLParser.ALTER); + this.state = 6061; + this.match(PostgreSQLParser.TABLE); + this.state = 6062; + this.match(PostgreSQLParser.IF_P); + this.state = 6063; + this.match(PostgreSQLParser.EXISTS); + this.state = 6064; + this.relation_expr(); + this.state = 6065; + this.match(PostgreSQLParser.RENAME); + this.state = 6066; + this.match(PostgreSQLParser.TO); + this.state = 6067; + this.name(); + break; + + case 23: + this.enterOuterAlt(localctx, 23); + this.state = 6069; + this.match(PostgreSQLParser.ALTER); + this.state = 6070; + this.match(PostgreSQLParser.SEQUENCE); + this.state = 6071; + this.qualified_name(); + this.state = 6072; + this.match(PostgreSQLParser.RENAME); + this.state = 6073; + this.match(PostgreSQLParser.TO); + this.state = 6074; + this.name(); + break; + + case 24: + this.enterOuterAlt(localctx, 24); + this.state = 6076; + this.match(PostgreSQLParser.ALTER); + this.state = 6077; + this.match(PostgreSQLParser.SEQUENCE); + this.state = 6078; + this.match(PostgreSQLParser.IF_P); + this.state = 6079; + this.match(PostgreSQLParser.EXISTS); + this.state = 6080; + this.qualified_name(); + this.state = 6081; + this.match(PostgreSQLParser.RENAME); + this.state = 6082; + this.match(PostgreSQLParser.TO); + this.state = 6083; + this.name(); + break; + + case 25: + this.enterOuterAlt(localctx, 25); + this.state = 6085; + this.match(PostgreSQLParser.ALTER); + this.state = 6086; + this.match(PostgreSQLParser.VIEW); + this.state = 6087; + this.qualified_name(); + this.state = 6088; + this.match(PostgreSQLParser.RENAME); + this.state = 6089; + this.match(PostgreSQLParser.TO); + this.state = 6090; + this.name(); + break; + + case 26: + this.enterOuterAlt(localctx, 26); + this.state = 6092; + this.match(PostgreSQLParser.ALTER); + this.state = 6093; + this.match(PostgreSQLParser.VIEW); + this.state = 6094; + this.match(PostgreSQLParser.IF_P); + this.state = 6095; + this.match(PostgreSQLParser.EXISTS); + this.state = 6096; + this.qualified_name(); + this.state = 6097; + this.match(PostgreSQLParser.RENAME); + this.state = 6098; + this.match(PostgreSQLParser.TO); + this.state = 6099; + this.name(); + break; + + case 27: + this.enterOuterAlt(localctx, 27); + this.state = 6101; + this.match(PostgreSQLParser.ALTER); + this.state = 6102; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 6103; + this.match(PostgreSQLParser.VIEW); + this.state = 6104; + this.qualified_name(); + this.state = 6105; + this.match(PostgreSQLParser.RENAME); + this.state = 6106; + this.match(PostgreSQLParser.TO); + this.state = 6107; + this.name(); + break; + + case 28: + this.enterOuterAlt(localctx, 28); + this.state = 6109; + this.match(PostgreSQLParser.ALTER); + this.state = 6110; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 6111; + this.match(PostgreSQLParser.VIEW); + this.state = 6112; + this.match(PostgreSQLParser.IF_P); + this.state = 6113; + this.match(PostgreSQLParser.EXISTS); + this.state = 6114; + this.qualified_name(); + this.state = 6115; + this.match(PostgreSQLParser.RENAME); + this.state = 6116; + this.match(PostgreSQLParser.TO); + this.state = 6117; + this.name(); + break; + + case 29: + this.enterOuterAlt(localctx, 29); + this.state = 6119; + this.match(PostgreSQLParser.ALTER); + this.state = 6120; + this.match(PostgreSQLParser.INDEX); + this.state = 6121; + this.qualified_name(); + this.state = 6122; + this.match(PostgreSQLParser.RENAME); + this.state = 6123; + this.match(PostgreSQLParser.TO); + this.state = 6124; + this.name(); + break; + + case 30: + this.enterOuterAlt(localctx, 30); + this.state = 6126; + this.match(PostgreSQLParser.ALTER); + this.state = 6127; + this.match(PostgreSQLParser.INDEX); + this.state = 6128; + this.match(PostgreSQLParser.IF_P); + this.state = 6129; + this.match(PostgreSQLParser.EXISTS); + this.state = 6130; + this.qualified_name(); + this.state = 6131; + this.match(PostgreSQLParser.RENAME); + this.state = 6132; + this.match(PostgreSQLParser.TO); + this.state = 6133; + this.name(); + break; + + case 31: + this.enterOuterAlt(localctx, 31); + this.state = 6135; + this.match(PostgreSQLParser.ALTER); + this.state = 6136; + this.match(PostgreSQLParser.FOREIGN); + this.state = 6137; + this.match(PostgreSQLParser.TABLE); + this.state = 6138; + this.relation_expr(); + this.state = 6139; + this.match(PostgreSQLParser.RENAME); + this.state = 6140; + this.match(PostgreSQLParser.TO); + this.state = 6141; + this.name(); + break; + + case 32: + this.enterOuterAlt(localctx, 32); + this.state = 6143; + this.match(PostgreSQLParser.ALTER); + this.state = 6144; + this.match(PostgreSQLParser.FOREIGN); + this.state = 6145; + this.match(PostgreSQLParser.TABLE); + this.state = 6146; + this.match(PostgreSQLParser.IF_P); + this.state = 6147; + this.match(PostgreSQLParser.EXISTS); + this.state = 6148; + this.relation_expr(); + this.state = 6149; + this.match(PostgreSQLParser.RENAME); + this.state = 6150; + this.match(PostgreSQLParser.TO); + this.state = 6151; + this.name(); + break; + + case 33: + this.enterOuterAlt(localctx, 33); + this.state = 6153; + this.match(PostgreSQLParser.ALTER); + this.state = 6154; + this.match(PostgreSQLParser.TABLE); + this.state = 6155; + this.relation_expr(); + this.state = 6156; + this.match(PostgreSQLParser.RENAME); + this.state = 6157; + this.opt_column(); + this.state = 6158; + this.name(); + this.state = 6159; + this.match(PostgreSQLParser.TO); + this.state = 6160; + this.name(); + break; + + case 34: + this.enterOuterAlt(localctx, 34); + this.state = 6162; + this.match(PostgreSQLParser.ALTER); + this.state = 6163; + this.match(PostgreSQLParser.TABLE); + this.state = 6164; + this.match(PostgreSQLParser.IF_P); + this.state = 6165; + this.match(PostgreSQLParser.EXISTS); + this.state = 6166; + this.relation_expr(); + this.state = 6167; + this.match(PostgreSQLParser.RENAME); + this.state = 6168; + this.opt_column(); + this.state = 6169; + this.name(); + this.state = 6170; + this.match(PostgreSQLParser.TO); + this.state = 6171; + this.name(); + break; + + case 35: + this.enterOuterAlt(localctx, 35); + this.state = 6173; + this.match(PostgreSQLParser.ALTER); + this.state = 6174; + this.match(PostgreSQLParser.VIEW); + this.state = 6175; + this.qualified_name(); + this.state = 6176; + this.match(PostgreSQLParser.RENAME); + this.state = 6177; + this.opt_column(); + this.state = 6178; + this.name(); + this.state = 6179; + this.match(PostgreSQLParser.TO); + this.state = 6180; + this.name(); + break; + + case 36: + this.enterOuterAlt(localctx, 36); + this.state = 6182; + this.match(PostgreSQLParser.ALTER); + this.state = 6183; + this.match(PostgreSQLParser.VIEW); + this.state = 6184; + this.match(PostgreSQLParser.IF_P); + this.state = 6185; + this.match(PostgreSQLParser.EXISTS); + this.state = 6186; + this.qualified_name(); + this.state = 6187; + this.match(PostgreSQLParser.RENAME); + this.state = 6188; + this.opt_column(); + this.state = 6189; + this.name(); + this.state = 6190; + this.match(PostgreSQLParser.TO); + this.state = 6191; + this.name(); + break; + + case 37: + this.enterOuterAlt(localctx, 37); + this.state = 6193; + this.match(PostgreSQLParser.ALTER); + this.state = 6194; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 6195; + this.match(PostgreSQLParser.VIEW); + this.state = 6196; + this.qualified_name(); + this.state = 6197; + this.match(PostgreSQLParser.RENAME); + this.state = 6198; + this.opt_column(); + this.state = 6199; + this.name(); + this.state = 6200; + this.match(PostgreSQLParser.TO); + this.state = 6201; + this.name(); + break; + + case 38: + this.enterOuterAlt(localctx, 38); + this.state = 6203; + this.match(PostgreSQLParser.ALTER); + this.state = 6204; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 6205; + this.match(PostgreSQLParser.VIEW); + this.state = 6206; + this.match(PostgreSQLParser.IF_P); + this.state = 6207; + this.match(PostgreSQLParser.EXISTS); + this.state = 6208; + this.qualified_name(); + this.state = 6209; + this.match(PostgreSQLParser.RENAME); + this.state = 6210; + this.opt_column(); + this.state = 6211; + this.name(); + this.state = 6212; + this.match(PostgreSQLParser.TO); + this.state = 6213; + this.name(); + break; + + case 39: + this.enterOuterAlt(localctx, 39); + this.state = 6215; + this.match(PostgreSQLParser.ALTER); + this.state = 6216; + this.match(PostgreSQLParser.TABLE); + this.state = 6217; + this.relation_expr(); + this.state = 6218; + this.match(PostgreSQLParser.RENAME); + this.state = 6219; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 6220; + this.name(); + this.state = 6221; + this.match(PostgreSQLParser.TO); + this.state = 6222; + this.name(); + break; + + case 40: + this.enterOuterAlt(localctx, 40); + this.state = 6224; + this.match(PostgreSQLParser.ALTER); + this.state = 6225; + this.match(PostgreSQLParser.TABLE); + this.state = 6226; + this.match(PostgreSQLParser.IF_P); + this.state = 6227; + this.match(PostgreSQLParser.EXISTS); + this.state = 6228; + this.relation_expr(); + this.state = 6229; + this.match(PostgreSQLParser.RENAME); + this.state = 6230; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 6231; + this.name(); + this.state = 6232; + this.match(PostgreSQLParser.TO); + this.state = 6233; + this.name(); + break; + + case 41: + this.enterOuterAlt(localctx, 41); + this.state = 6235; + this.match(PostgreSQLParser.ALTER); + this.state = 6236; + this.match(PostgreSQLParser.FOREIGN); + this.state = 6237; + this.match(PostgreSQLParser.TABLE); + this.state = 6238; + this.relation_expr(); + this.state = 6239; + this.match(PostgreSQLParser.RENAME); + this.state = 6240; + this.opt_column(); + this.state = 6241; + this.name(); + this.state = 6242; + this.match(PostgreSQLParser.TO); + this.state = 6243; + this.name(); + break; + + case 42: + this.enterOuterAlt(localctx, 42); + this.state = 6245; + this.match(PostgreSQLParser.ALTER); + this.state = 6246; + this.match(PostgreSQLParser.FOREIGN); + this.state = 6247; + this.match(PostgreSQLParser.TABLE); + this.state = 6248; + this.match(PostgreSQLParser.IF_P); + this.state = 6249; + this.match(PostgreSQLParser.EXISTS); + this.state = 6250; + this.relation_expr(); + this.state = 6251; + this.match(PostgreSQLParser.RENAME); + this.state = 6252; + this.opt_column(); + this.state = 6253; + this.name(); + this.state = 6254; + this.match(PostgreSQLParser.TO); + this.state = 6255; + this.name(); + break; + + case 43: + this.enterOuterAlt(localctx, 43); + this.state = 6257; + this.match(PostgreSQLParser.ALTER); + this.state = 6258; + this.match(PostgreSQLParser.RULE); + this.state = 6259; + this.name(); + this.state = 6260; + this.match(PostgreSQLParser.ON); + this.state = 6261; + this.qualified_name(); + this.state = 6262; + this.match(PostgreSQLParser.RENAME); + this.state = 6263; + this.match(PostgreSQLParser.TO); + this.state = 6264; + this.name(); + break; + + case 44: + this.enterOuterAlt(localctx, 44); + this.state = 6266; + this.match(PostgreSQLParser.ALTER); + this.state = 6267; + this.match(PostgreSQLParser.TRIGGER); + this.state = 6268; + this.name(); + this.state = 6269; + this.match(PostgreSQLParser.ON); + this.state = 6270; + this.qualified_name(); + this.state = 6271; + this.match(PostgreSQLParser.RENAME); + this.state = 6272; + this.match(PostgreSQLParser.TO); + this.state = 6273; + this.name(); + break; + + case 45: + this.enterOuterAlt(localctx, 45); + this.state = 6275; + this.match(PostgreSQLParser.ALTER); + this.state = 6276; + this.match(PostgreSQLParser.EVENT); + this.state = 6277; + this.match(PostgreSQLParser.TRIGGER); + this.state = 6278; + this.name(); + this.state = 6279; + this.match(PostgreSQLParser.RENAME); + this.state = 6280; + this.match(PostgreSQLParser.TO); + this.state = 6281; + this.name(); + break; + + case 46: + this.enterOuterAlt(localctx, 46); + this.state = 6283; + this.match(PostgreSQLParser.ALTER); + this.state = 6284; + this.match(PostgreSQLParser.ROLE); + this.state = 6285; + this.roleid(); + this.state = 6286; + this.match(PostgreSQLParser.RENAME); + this.state = 6287; + this.match(PostgreSQLParser.TO); + this.state = 6288; + this.roleid(); + break; + + case 47: + this.enterOuterAlt(localctx, 47); + this.state = 6290; + this.match(PostgreSQLParser.ALTER); + this.state = 6291; + this.match(PostgreSQLParser.USER); + this.state = 6292; + this.roleid(); + this.state = 6293; + this.match(PostgreSQLParser.RENAME); + this.state = 6294; + this.match(PostgreSQLParser.TO); + this.state = 6295; + this.roleid(); + break; + + case 48: + this.enterOuterAlt(localctx, 48); + this.state = 6297; + this.match(PostgreSQLParser.ALTER); + this.state = 6298; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 6299; + this.name(); + this.state = 6300; + this.match(PostgreSQLParser.RENAME); + this.state = 6301; + this.match(PostgreSQLParser.TO); + this.state = 6302; + this.name(); + break; + + case 49: + this.enterOuterAlt(localctx, 49); + this.state = 6304; + this.match(PostgreSQLParser.ALTER); + this.state = 6305; + this.match(PostgreSQLParser.STATISTICS); + this.state = 6306; + this.any_name(); + this.state = 6307; + this.match(PostgreSQLParser.RENAME); + this.state = 6308; + this.match(PostgreSQLParser.TO); + this.state = 6309; + this.name(); + break; + + case 50: + this.enterOuterAlt(localctx, 50); + this.state = 6311; + this.match(PostgreSQLParser.ALTER); + this.state = 6312; + this.match(PostgreSQLParser.TEXT_P); + this.state = 6313; + this.match(PostgreSQLParser.SEARCH); + this.state = 6314; + this.match(PostgreSQLParser.PARSER); + this.state = 6315; + this.any_name(); + this.state = 6316; + this.match(PostgreSQLParser.RENAME); + this.state = 6317; + this.match(PostgreSQLParser.TO); + this.state = 6318; + this.name(); + break; + + case 51: + this.enterOuterAlt(localctx, 51); + this.state = 6320; + this.match(PostgreSQLParser.ALTER); + this.state = 6321; + this.match(PostgreSQLParser.TEXT_P); + this.state = 6322; + this.match(PostgreSQLParser.SEARCH); + this.state = 6323; + this.match(PostgreSQLParser.DICTIONARY); + this.state = 6324; + this.any_name(); + this.state = 6325; + this.match(PostgreSQLParser.RENAME); + this.state = 6326; + this.match(PostgreSQLParser.TO); + this.state = 6327; + this.name(); + break; + + case 52: + this.enterOuterAlt(localctx, 52); + this.state = 6329; + this.match(PostgreSQLParser.ALTER); + this.state = 6330; + this.match(PostgreSQLParser.TEXT_P); + this.state = 6331; + this.match(PostgreSQLParser.SEARCH); + this.state = 6332; + this.match(PostgreSQLParser.TEMPLATE); + this.state = 6333; + this.any_name(); + this.state = 6334; + this.match(PostgreSQLParser.RENAME); + this.state = 6335; + this.match(PostgreSQLParser.TO); + this.state = 6336; + this.name(); + break; + + case 53: + this.enterOuterAlt(localctx, 53); + this.state = 6338; + this.match(PostgreSQLParser.ALTER); + this.state = 6339; + this.match(PostgreSQLParser.TEXT_P); + this.state = 6340; + this.match(PostgreSQLParser.SEARCH); + this.state = 6341; + this.match(PostgreSQLParser.CONFIGURATION); + this.state = 6342; + this.any_name(); + this.state = 6343; + this.match(PostgreSQLParser.RENAME); + this.state = 6344; + this.match(PostgreSQLParser.TO); + this.state = 6345; + this.name(); + break; + + case 54: + this.enterOuterAlt(localctx, 54); + this.state = 6347; + this.match(PostgreSQLParser.ALTER); + this.state = 6348; + this.match(PostgreSQLParser.TYPE_P); + this.state = 6349; + this.any_name(); + this.state = 6350; + this.match(PostgreSQLParser.RENAME); + this.state = 6351; + this.match(PostgreSQLParser.TO); + this.state = 6352; + this.name(); + break; + + case 55: + this.enterOuterAlt(localctx, 55); + this.state = 6354; + this.match(PostgreSQLParser.ALTER); + this.state = 6355; + this.match(PostgreSQLParser.TYPE_P); + this.state = 6356; + this.any_name(); + this.state = 6357; + this.match(PostgreSQLParser.RENAME); + this.state = 6358; + this.match(PostgreSQLParser.ATTRIBUTE); + this.state = 6359; + this.name(); + this.state = 6360; + this.match(PostgreSQLParser.TO); + this.state = 6361; + this.name(); + this.state = 6362; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_columnContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_column; + return this; +} + +Opt_columnContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_columnContext.prototype.constructor = Opt_columnContext; + +Opt_columnContext.prototype.COLUMN = function() { + return this.getToken(PostgreSQLParser.COLUMN, 0); +}; + +Opt_columnContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_column(this); + } +}; + +Opt_columnContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_column(this); + } +}; + +Opt_columnContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_column(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_columnContext = Opt_columnContext; + +PostgreSQLParser.prototype.opt_column = function() { + + var localctx = new Opt_columnContext(this, this._ctx, this.state); + this.enterRule(localctx, 724, PostgreSQLParser.RULE_opt_column); + try { + this.state = 6368; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,308,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 6366; + this.match(PostgreSQLParser.COLUMN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_set_dataContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_set_data; + return this; +} + +Opt_set_dataContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_set_dataContext.prototype.constructor = Opt_set_dataContext; + +Opt_set_dataContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +Opt_set_dataContext.prototype.DATA_P = function() { + return this.getToken(PostgreSQLParser.DATA_P, 0); +}; + +Opt_set_dataContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_set_data(this); + } +}; + +Opt_set_dataContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_set_data(this); + } +}; + +Opt_set_dataContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_set_data(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_set_dataContext = Opt_set_dataContext; + +PostgreSQLParser.prototype.opt_set_data = function() { + + var localctx = new Opt_set_dataContext(this, this._ctx, this.state); + this.enterRule(localctx, 726, PostgreSQLParser.RULE_opt_set_data); + try { + this.state = 6373; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SET: + this.enterOuterAlt(localctx, 1); + this.state = 6370; + this.match(PostgreSQLParser.SET); + this.state = 6371; + this.match(PostgreSQLParser.DATA_P); + break; + case PostgreSQLParser.TYPE_P: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterobjectdependsstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterobjectdependsstmt; + return this; +} + +AlterobjectdependsstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterobjectdependsstmtContext.prototype.constructor = AlterobjectdependsstmtContext; + +AlterobjectdependsstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterobjectdependsstmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +AlterobjectdependsstmtContext.prototype.function_with_argtypes = function() { + return this.getTypedRuleContext(Function_with_argtypesContext,0); +}; + +AlterobjectdependsstmtContext.prototype.opt_no = function() { + return this.getTypedRuleContext(Opt_noContext,0); +}; + +AlterobjectdependsstmtContext.prototype.DEPENDS = function() { + return this.getToken(PostgreSQLParser.DEPENDS, 0); +}; + +AlterobjectdependsstmtContext.prototype.ON = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.ON); + } else { + return this.getToken(PostgreSQLParser.ON, i); + } +}; + + +AlterobjectdependsstmtContext.prototype.EXTENSION = function() { + return this.getToken(PostgreSQLParser.EXTENSION, 0); +}; + +AlterobjectdependsstmtContext.prototype.name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(NameContext); + } else { + return this.getTypedRuleContext(NameContext,i); + } +}; + +AlterobjectdependsstmtContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +AlterobjectdependsstmtContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +AlterobjectdependsstmtContext.prototype.TRIGGER = function() { + return this.getToken(PostgreSQLParser.TRIGGER, 0); +}; + +AlterobjectdependsstmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +AlterobjectdependsstmtContext.prototype.MATERIALIZED = function() { + return this.getToken(PostgreSQLParser.MATERIALIZED, 0); +}; + +AlterobjectdependsstmtContext.prototype.VIEW = function() { + return this.getToken(PostgreSQLParser.VIEW, 0); +}; + +AlterobjectdependsstmtContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +AlterobjectdependsstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterobjectdependsstmt(this); + } +}; + +AlterobjectdependsstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterobjectdependsstmt(this); + } +}; + +AlterobjectdependsstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterobjectdependsstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterobjectdependsstmtContext = AlterobjectdependsstmtContext; + +PostgreSQLParser.prototype.alterobjectdependsstmt = function() { + + var localctx = new AlterobjectdependsstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 728, PostgreSQLParser.RULE_alterobjectdependsstmt); + try { + this.state = 6432; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,310,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 6375; + this.match(PostgreSQLParser.ALTER); + this.state = 6376; + this.match(PostgreSQLParser.FUNCTION); + this.state = 6377; + this.function_with_argtypes(); + this.state = 6378; + this.opt_no(); + this.state = 6379; + this.match(PostgreSQLParser.DEPENDS); + this.state = 6380; + this.match(PostgreSQLParser.ON); + this.state = 6381; + this.match(PostgreSQLParser.EXTENSION); + this.state = 6382; + this.name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 6384; + this.match(PostgreSQLParser.ALTER); + this.state = 6385; + this.match(PostgreSQLParser.PROCEDURE); + this.state = 6386; + this.function_with_argtypes(); + this.state = 6387; + this.opt_no(); + this.state = 6388; + this.match(PostgreSQLParser.DEPENDS); + this.state = 6389; + this.match(PostgreSQLParser.ON); + this.state = 6390; + this.match(PostgreSQLParser.EXTENSION); + this.state = 6391; + this.name(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 6393; + this.match(PostgreSQLParser.ALTER); + this.state = 6394; + this.match(PostgreSQLParser.ROUTINE); + this.state = 6395; + this.function_with_argtypes(); + this.state = 6396; + this.opt_no(); + this.state = 6397; + this.match(PostgreSQLParser.DEPENDS); + this.state = 6398; + this.match(PostgreSQLParser.ON); + this.state = 6399; + this.match(PostgreSQLParser.EXTENSION); + this.state = 6400; + this.name(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 6402; + this.match(PostgreSQLParser.ALTER); + this.state = 6403; + this.match(PostgreSQLParser.TRIGGER); + this.state = 6404; + this.name(); + this.state = 6405; + this.match(PostgreSQLParser.ON); + this.state = 6406; + this.qualified_name(); + this.state = 6407; + this.opt_no(); + this.state = 6408; + this.match(PostgreSQLParser.DEPENDS); + this.state = 6409; + this.match(PostgreSQLParser.ON); + this.state = 6410; + this.match(PostgreSQLParser.EXTENSION); + this.state = 6411; + this.name(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 6413; + this.match(PostgreSQLParser.ALTER); + this.state = 6414; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 6415; + this.match(PostgreSQLParser.VIEW); + this.state = 6416; + this.qualified_name(); + this.state = 6417; + this.opt_no(); + this.state = 6418; + this.match(PostgreSQLParser.DEPENDS); + this.state = 6419; + this.match(PostgreSQLParser.ON); + this.state = 6420; + this.match(PostgreSQLParser.EXTENSION); + this.state = 6421; + this.name(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 6423; + this.match(PostgreSQLParser.ALTER); + this.state = 6424; + this.match(PostgreSQLParser.INDEX); + this.state = 6425; + this.qualified_name(); + this.state = 6426; + this.opt_no(); + this.state = 6427; + this.match(PostgreSQLParser.DEPENDS); + this.state = 6428; + this.match(PostgreSQLParser.ON); + this.state = 6429; + this.match(PostgreSQLParser.EXTENSION); + this.state = 6430; + this.name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_noContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_no; + return this; +} + +Opt_noContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_noContext.prototype.constructor = Opt_noContext; + +Opt_noContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Opt_noContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_no(this); + } +}; + +Opt_noContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_no(this); + } +}; + +Opt_noContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_no(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_noContext = Opt_noContext; + +PostgreSQLParser.prototype.opt_no = function() { + + var localctx = new Opt_noContext(this, this._ctx, this.state); + this.enterRule(localctx, 730, PostgreSQLParser.RULE_opt_no); + try { + this.state = 6436; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NO: + this.enterOuterAlt(localctx, 1); + this.state = 6434; + this.match(PostgreSQLParser.NO); + break; + case PostgreSQLParser.DEPENDS: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterobjectschemastmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterobjectschemastmt; + return this; +} + +AlterobjectschemastmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterobjectschemastmtContext.prototype.constructor = AlterobjectschemastmtContext; + +AlterobjectschemastmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterobjectschemastmtContext.prototype.AGGREGATE = function() { + return this.getToken(PostgreSQLParser.AGGREGATE, 0); +}; + +AlterobjectschemastmtContext.prototype.aggregate_with_argtypes = function() { + return this.getTypedRuleContext(Aggregate_with_argtypesContext,0); +}; + +AlterobjectschemastmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AlterobjectschemastmtContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +AlterobjectschemastmtContext.prototype.name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(NameContext); + } else { + return this.getTypedRuleContext(NameContext,i); + } +}; + +AlterobjectschemastmtContext.prototype.COLLATION = function() { + return this.getToken(PostgreSQLParser.COLLATION, 0); +}; + +AlterobjectschemastmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AlterobjectschemastmtContext.prototype.CONVERSION_P = function() { + return this.getToken(PostgreSQLParser.CONVERSION_P, 0); +}; + +AlterobjectschemastmtContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +AlterobjectschemastmtContext.prototype.EXTENSION = function() { + return this.getToken(PostgreSQLParser.EXTENSION, 0); +}; + +AlterobjectschemastmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +AlterobjectschemastmtContext.prototype.function_with_argtypes = function() { + return this.getTypedRuleContext(Function_with_argtypesContext,0); +}; + +AlterobjectschemastmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +AlterobjectschemastmtContext.prototype.operator_with_argtypes = function() { + return this.getTypedRuleContext(Operator_with_argtypesContext,0); +}; + +AlterobjectschemastmtContext.prototype.CLASS = function() { + return this.getToken(PostgreSQLParser.CLASS, 0); +}; + +AlterobjectschemastmtContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +AlterobjectschemastmtContext.prototype.FAMILY = function() { + return this.getToken(PostgreSQLParser.FAMILY, 0); +}; + +AlterobjectschemastmtContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +AlterobjectschemastmtContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +AlterobjectschemastmtContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +AlterobjectschemastmtContext.prototype.relation_expr = function() { + return this.getTypedRuleContext(Relation_exprContext,0); +}; + +AlterobjectschemastmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +AlterobjectschemastmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +AlterobjectschemastmtContext.prototype.STATISTICS = function() { + return this.getToken(PostgreSQLParser.STATISTICS, 0); +}; + +AlterobjectschemastmtContext.prototype.TEXT_P = function() { + return this.getToken(PostgreSQLParser.TEXT_P, 0); +}; + +AlterobjectschemastmtContext.prototype.SEARCH = function() { + return this.getToken(PostgreSQLParser.SEARCH, 0); +}; + +AlterobjectschemastmtContext.prototype.PARSER = function() { + return this.getToken(PostgreSQLParser.PARSER, 0); +}; + +AlterobjectschemastmtContext.prototype.DICTIONARY = function() { + return this.getToken(PostgreSQLParser.DICTIONARY, 0); +}; + +AlterobjectschemastmtContext.prototype.TEMPLATE = function() { + return this.getToken(PostgreSQLParser.TEMPLATE, 0); +}; + +AlterobjectschemastmtContext.prototype.CONFIGURATION = function() { + return this.getToken(PostgreSQLParser.CONFIGURATION, 0); +}; + +AlterobjectschemastmtContext.prototype.SEQUENCE = function() { + return this.getToken(PostgreSQLParser.SEQUENCE, 0); +}; + +AlterobjectschemastmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +AlterobjectschemastmtContext.prototype.VIEW = function() { + return this.getToken(PostgreSQLParser.VIEW, 0); +}; + +AlterobjectschemastmtContext.prototype.MATERIALIZED = function() { + return this.getToken(PostgreSQLParser.MATERIALIZED, 0); +}; + +AlterobjectschemastmtContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +AlterobjectschemastmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +AlterobjectschemastmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterobjectschemastmt(this); + } +}; + +AlterobjectschemastmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterobjectschemastmt(this); + } +}; + +AlterobjectschemastmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterobjectschemastmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterobjectschemastmtContext = AlterobjectschemastmtContext; + +PostgreSQLParser.prototype.alterobjectschemastmt = function() { + + var localctx = new AlterobjectschemastmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 732, PostgreSQLParser.RULE_alterobjectschemastmt); + try { + this.state = 6655; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,312,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 6438; + this.match(PostgreSQLParser.ALTER); + this.state = 6439; + this.match(PostgreSQLParser.AGGREGATE); + this.state = 6440; + this.aggregate_with_argtypes(); + this.state = 6441; + this.match(PostgreSQLParser.SET); + this.state = 6442; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6443; + this.name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 6445; + this.match(PostgreSQLParser.ALTER); + this.state = 6446; + this.match(PostgreSQLParser.COLLATION); + this.state = 6447; + this.any_name(); + this.state = 6448; + this.match(PostgreSQLParser.SET); + this.state = 6449; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6450; + this.name(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 6452; + this.match(PostgreSQLParser.ALTER); + this.state = 6453; + this.match(PostgreSQLParser.CONVERSION_P); + this.state = 6454; + this.any_name(); + this.state = 6455; + this.match(PostgreSQLParser.SET); + this.state = 6456; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6457; + this.name(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 6459; + this.match(PostgreSQLParser.ALTER); + this.state = 6460; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 6461; + this.any_name(); + this.state = 6462; + this.match(PostgreSQLParser.SET); + this.state = 6463; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6464; + this.name(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 6466; + this.match(PostgreSQLParser.ALTER); + this.state = 6467; + this.match(PostgreSQLParser.EXTENSION); + this.state = 6468; + this.name(); + this.state = 6469; + this.match(PostgreSQLParser.SET); + this.state = 6470; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6471; + this.name(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 6473; + this.match(PostgreSQLParser.ALTER); + this.state = 6474; + this.match(PostgreSQLParser.FUNCTION); + this.state = 6475; + this.function_with_argtypes(); + this.state = 6476; + this.match(PostgreSQLParser.SET); + this.state = 6477; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6478; + this.name(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 6480; + this.match(PostgreSQLParser.ALTER); + this.state = 6481; + this.match(PostgreSQLParser.OPERATOR); + this.state = 6482; + this.operator_with_argtypes(); + this.state = 6483; + this.match(PostgreSQLParser.SET); + this.state = 6484; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6485; + this.name(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 6487; + this.match(PostgreSQLParser.ALTER); + this.state = 6488; + this.match(PostgreSQLParser.OPERATOR); + this.state = 6489; + this.match(PostgreSQLParser.CLASS); + this.state = 6490; + this.any_name(); + this.state = 6491; + this.match(PostgreSQLParser.USING); + this.state = 6492; + this.name(); + this.state = 6493; + this.match(PostgreSQLParser.SET); + this.state = 6494; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6495; + this.name(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 6497; + this.match(PostgreSQLParser.ALTER); + this.state = 6498; + this.match(PostgreSQLParser.OPERATOR); + this.state = 6499; + this.match(PostgreSQLParser.FAMILY); + this.state = 6500; + this.any_name(); + this.state = 6501; + this.match(PostgreSQLParser.USING); + this.state = 6502; + this.name(); + this.state = 6503; + this.match(PostgreSQLParser.SET); + this.state = 6504; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6505; + this.name(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 6507; + this.match(PostgreSQLParser.ALTER); + this.state = 6508; + this.match(PostgreSQLParser.PROCEDURE); + this.state = 6509; + this.function_with_argtypes(); + this.state = 6510; + this.match(PostgreSQLParser.SET); + this.state = 6511; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6512; + this.name(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 6514; + this.match(PostgreSQLParser.ALTER); + this.state = 6515; + this.match(PostgreSQLParser.ROUTINE); + this.state = 6516; + this.function_with_argtypes(); + this.state = 6517; + this.match(PostgreSQLParser.SET); + this.state = 6518; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6519; + this.name(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 6521; + this.match(PostgreSQLParser.ALTER); + this.state = 6522; + this.match(PostgreSQLParser.TABLE); + this.state = 6523; + this.relation_expr(); + this.state = 6524; + this.match(PostgreSQLParser.SET); + this.state = 6525; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6526; + this.name(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 6528; + this.match(PostgreSQLParser.ALTER); + this.state = 6529; + this.match(PostgreSQLParser.TABLE); + this.state = 6530; + this.match(PostgreSQLParser.IF_P); + this.state = 6531; + this.match(PostgreSQLParser.EXISTS); + this.state = 6532; + this.relation_expr(); + this.state = 6533; + this.match(PostgreSQLParser.SET); + this.state = 6534; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6535; + this.name(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 6537; + this.match(PostgreSQLParser.ALTER); + this.state = 6538; + this.match(PostgreSQLParser.STATISTICS); + this.state = 6539; + this.any_name(); + this.state = 6540; + this.match(PostgreSQLParser.SET); + this.state = 6541; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6542; + this.name(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 6544; + this.match(PostgreSQLParser.ALTER); + this.state = 6545; + this.match(PostgreSQLParser.TEXT_P); + this.state = 6546; + this.match(PostgreSQLParser.SEARCH); + this.state = 6547; + this.match(PostgreSQLParser.PARSER); + this.state = 6548; + this.any_name(); + this.state = 6549; + this.match(PostgreSQLParser.SET); + this.state = 6550; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6551; + this.name(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 6553; + this.match(PostgreSQLParser.ALTER); + this.state = 6554; + this.match(PostgreSQLParser.TEXT_P); + this.state = 6555; + this.match(PostgreSQLParser.SEARCH); + this.state = 6556; + this.match(PostgreSQLParser.DICTIONARY); + this.state = 6557; + this.any_name(); + this.state = 6558; + this.match(PostgreSQLParser.SET); + this.state = 6559; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6560; + this.name(); + break; + + case 17: + this.enterOuterAlt(localctx, 17); + this.state = 6562; + this.match(PostgreSQLParser.ALTER); + this.state = 6563; + this.match(PostgreSQLParser.TEXT_P); + this.state = 6564; + this.match(PostgreSQLParser.SEARCH); + this.state = 6565; + this.match(PostgreSQLParser.TEMPLATE); + this.state = 6566; + this.any_name(); + this.state = 6567; + this.match(PostgreSQLParser.SET); + this.state = 6568; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6569; + this.name(); + break; + + case 18: + this.enterOuterAlt(localctx, 18); + this.state = 6571; + this.match(PostgreSQLParser.ALTER); + this.state = 6572; + this.match(PostgreSQLParser.TEXT_P); + this.state = 6573; + this.match(PostgreSQLParser.SEARCH); + this.state = 6574; + this.match(PostgreSQLParser.CONFIGURATION); + this.state = 6575; + this.any_name(); + this.state = 6576; + this.match(PostgreSQLParser.SET); + this.state = 6577; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6578; + this.name(); + break; + + case 19: + this.enterOuterAlt(localctx, 19); + this.state = 6580; + this.match(PostgreSQLParser.ALTER); + this.state = 6581; + this.match(PostgreSQLParser.SEQUENCE); + this.state = 6582; + this.qualified_name(); + this.state = 6583; + this.match(PostgreSQLParser.SET); + this.state = 6584; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6585; + this.name(); + break; + + case 20: + this.enterOuterAlt(localctx, 20); + this.state = 6587; + this.match(PostgreSQLParser.ALTER); + this.state = 6588; + this.match(PostgreSQLParser.SEQUENCE); + this.state = 6589; + this.match(PostgreSQLParser.IF_P); + this.state = 6590; + this.match(PostgreSQLParser.EXISTS); + this.state = 6591; + this.qualified_name(); + this.state = 6592; + this.match(PostgreSQLParser.SET); + this.state = 6593; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6594; + this.name(); + break; + + case 21: + this.enterOuterAlt(localctx, 21); + this.state = 6596; + this.match(PostgreSQLParser.ALTER); + this.state = 6597; + this.match(PostgreSQLParser.VIEW); + this.state = 6598; + this.qualified_name(); + this.state = 6599; + this.match(PostgreSQLParser.SET); + this.state = 6600; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6601; + this.name(); + break; + + case 22: + this.enterOuterAlt(localctx, 22); + this.state = 6603; + this.match(PostgreSQLParser.ALTER); + this.state = 6604; + this.match(PostgreSQLParser.VIEW); + this.state = 6605; + this.match(PostgreSQLParser.IF_P); + this.state = 6606; + this.match(PostgreSQLParser.EXISTS); + this.state = 6607; + this.qualified_name(); + this.state = 6608; + this.match(PostgreSQLParser.SET); + this.state = 6609; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6610; + this.name(); + break; + + case 23: + this.enterOuterAlt(localctx, 23); + this.state = 6612; + this.match(PostgreSQLParser.ALTER); + this.state = 6613; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 6614; + this.match(PostgreSQLParser.VIEW); + this.state = 6615; + this.qualified_name(); + this.state = 6616; + this.match(PostgreSQLParser.SET); + this.state = 6617; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6618; + this.name(); + break; + + case 24: + this.enterOuterAlt(localctx, 24); + this.state = 6620; + this.match(PostgreSQLParser.ALTER); + this.state = 6621; + this.match(PostgreSQLParser.MATERIALIZED); + this.state = 6622; + this.match(PostgreSQLParser.VIEW); + this.state = 6623; + this.match(PostgreSQLParser.IF_P); + this.state = 6624; + this.match(PostgreSQLParser.EXISTS); + this.state = 6625; + this.qualified_name(); + this.state = 6626; + this.match(PostgreSQLParser.SET); + this.state = 6627; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6628; + this.name(); + break; + + case 25: + this.enterOuterAlt(localctx, 25); + this.state = 6630; + this.match(PostgreSQLParser.ALTER); + this.state = 6631; + this.match(PostgreSQLParser.FOREIGN); + this.state = 6632; + this.match(PostgreSQLParser.TABLE); + this.state = 6633; + this.relation_expr(); + this.state = 6634; + this.match(PostgreSQLParser.SET); + this.state = 6635; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6636; + this.name(); + break; + + case 26: + this.enterOuterAlt(localctx, 26); + this.state = 6638; + this.match(PostgreSQLParser.ALTER); + this.state = 6639; + this.match(PostgreSQLParser.FOREIGN); + this.state = 6640; + this.match(PostgreSQLParser.TABLE); + this.state = 6641; + this.match(PostgreSQLParser.IF_P); + this.state = 6642; + this.match(PostgreSQLParser.EXISTS); + this.state = 6643; + this.relation_expr(); + this.state = 6644; + this.match(PostgreSQLParser.SET); + this.state = 6645; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6646; + this.name(); + break; + + case 27: + this.enterOuterAlt(localctx, 27); + this.state = 6648; + this.match(PostgreSQLParser.ALTER); + this.state = 6649; + this.match(PostgreSQLParser.TYPE_P); + this.state = 6650; + this.any_name(); + this.state = 6651; + this.match(PostgreSQLParser.SET); + this.state = 6652; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6653; + this.name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlteroperatorstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alteroperatorstmt; + return this; +} + +AlteroperatorstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlteroperatorstmtContext.prototype.constructor = AlteroperatorstmtContext; + +AlteroperatorstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlteroperatorstmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +AlteroperatorstmtContext.prototype.operator_with_argtypes = function() { + return this.getTypedRuleContext(Operator_with_argtypesContext,0); +}; + +AlteroperatorstmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AlteroperatorstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +AlteroperatorstmtContext.prototype.operator_def_list = function() { + return this.getTypedRuleContext(Operator_def_listContext,0); +}; + +AlteroperatorstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +AlteroperatorstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlteroperatorstmt(this); + } +}; + +AlteroperatorstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlteroperatorstmt(this); + } +}; + +AlteroperatorstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlteroperatorstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlteroperatorstmtContext = AlteroperatorstmtContext; + +PostgreSQLParser.prototype.alteroperatorstmt = function() { + + var localctx = new AlteroperatorstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 734, PostgreSQLParser.RULE_alteroperatorstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 6657; + this.match(PostgreSQLParser.ALTER); + this.state = 6658; + this.match(PostgreSQLParser.OPERATOR); + this.state = 6659; + this.operator_with_argtypes(); + this.state = 6660; + this.match(PostgreSQLParser.SET); + this.state = 6661; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 6662; + this.operator_def_list(); + this.state = 6663; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Operator_def_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_operator_def_list; + return this; +} + +Operator_def_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Operator_def_listContext.prototype.constructor = Operator_def_listContext; + +Operator_def_listContext.prototype.operator_def_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Operator_def_elemContext); + } else { + return this.getTypedRuleContext(Operator_def_elemContext,i); + } +}; + +Operator_def_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Operator_def_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOperator_def_list(this); + } +}; + +Operator_def_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOperator_def_list(this); + } +}; + +Operator_def_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOperator_def_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Operator_def_listContext = Operator_def_listContext; + +PostgreSQLParser.prototype.operator_def_list = function() { + + var localctx = new Operator_def_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 736, PostgreSQLParser.RULE_operator_def_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 6665; + this.operator_def_elem(); + this.state = 6670; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 6666; + this.match(PostgreSQLParser.COMMA); + this.state = 6667; + this.operator_def_elem(); + this.state = 6672; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Operator_def_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_operator_def_elem; + return this; +} + +Operator_def_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Operator_def_elemContext.prototype.constructor = Operator_def_elemContext; + +Operator_def_elemContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +Operator_def_elemContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +Operator_def_elemContext.prototype.NONE = function() { + return this.getToken(PostgreSQLParser.NONE, 0); +}; + +Operator_def_elemContext.prototype.operator_def_arg = function() { + return this.getTypedRuleContext(Operator_def_argContext,0); +}; + +Operator_def_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOperator_def_elem(this); + } +}; + +Operator_def_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOperator_def_elem(this); + } +}; + +Operator_def_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOperator_def_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Operator_def_elemContext = Operator_def_elemContext; + +PostgreSQLParser.prototype.operator_def_elem = function() { + + var localctx = new Operator_def_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 738, PostgreSQLParser.RULE_operator_def_elem); + try { + this.state = 6681; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,314,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 6673; + this.collabel(); + this.state = 6674; + this.match(PostgreSQLParser.EQUAL); + this.state = 6675; + this.match(PostgreSQLParser.NONE); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 6677; + this.collabel(); + this.state = 6678; + this.match(PostgreSQLParser.EQUAL); + this.state = 6679; + this.operator_def_arg(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Operator_def_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_operator_def_arg; + return this; +} + +Operator_def_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Operator_def_argContext.prototype.constructor = Operator_def_argContext; + +Operator_def_argContext.prototype.func_type = function() { + return this.getTypedRuleContext(Func_typeContext,0); +}; + +Operator_def_argContext.prototype.reserved_keyword = function() { + return this.getTypedRuleContext(Reserved_keywordContext,0); +}; + +Operator_def_argContext.prototype.qual_all_op = function() { + return this.getTypedRuleContext(Qual_all_opContext,0); +}; + +Operator_def_argContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +Operator_def_argContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Operator_def_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOperator_def_arg(this); + } +}; + +Operator_def_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOperator_def_arg(this); + } +}; + +Operator_def_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOperator_def_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Operator_def_argContext = Operator_def_argContext; + +PostgreSQLParser.prototype.operator_def_arg = function() { + + var localctx = new Operator_def_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 740, PostgreSQLParser.RULE_operator_def_arg); + try { + this.state = 6688; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,315,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 6683; + this.func_type(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 6684; + this.reserved_keyword(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 6685; + this.qual_all_op(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 6686; + this.numericonly(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 6687; + this.sconst(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltertypestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altertypestmt; + return this; +} + +AltertypestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltertypestmtContext.prototype.constructor = AltertypestmtContext; + +AltertypestmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AltertypestmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +AltertypestmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AltertypestmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AltertypestmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +AltertypestmtContext.prototype.operator_def_list = function() { + return this.getTypedRuleContext(Operator_def_listContext,0); +}; + +AltertypestmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +AltertypestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltertypestmt(this); + } +}; + +AltertypestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltertypestmt(this); + } +}; + +AltertypestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltertypestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltertypestmtContext = AltertypestmtContext; + +PostgreSQLParser.prototype.altertypestmt = function() { + + var localctx = new AltertypestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 742, PostgreSQLParser.RULE_altertypestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 6690; + this.match(PostgreSQLParser.ALTER); + this.state = 6691; + this.match(PostgreSQLParser.TYPE_P); + this.state = 6692; + this.any_name(); + this.state = 6693; + this.match(PostgreSQLParser.SET); + this.state = 6694; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 6695; + this.operator_def_list(); + this.state = 6696; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterownerstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterownerstmt; + return this; +} + +AlterownerstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterownerstmtContext.prototype.constructor = AlterownerstmtContext; + +AlterownerstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterownerstmtContext.prototype.AGGREGATE = function() { + return this.getToken(PostgreSQLParser.AGGREGATE, 0); +}; + +AlterownerstmtContext.prototype.aggregate_with_argtypes = function() { + return this.getTypedRuleContext(Aggregate_with_argtypesContext,0); +}; + +AlterownerstmtContext.prototype.OWNER = function() { + return this.getToken(PostgreSQLParser.OWNER, 0); +}; + +AlterownerstmtContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +AlterownerstmtContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +AlterownerstmtContext.prototype.COLLATION = function() { + return this.getToken(PostgreSQLParser.COLLATION, 0); +}; + +AlterownerstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AlterownerstmtContext.prototype.CONVERSION_P = function() { + return this.getToken(PostgreSQLParser.CONVERSION_P, 0); +}; + +AlterownerstmtContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +AlterownerstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AlterownerstmtContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +AlterownerstmtContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +AlterownerstmtContext.prototype.function_with_argtypes = function() { + return this.getTypedRuleContext(Function_with_argtypesContext,0); +}; + +AlterownerstmtContext.prototype.opt_procedural = function() { + return this.getTypedRuleContext(Opt_proceduralContext,0); +}; + +AlterownerstmtContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +AlterownerstmtContext.prototype.LARGE_P = function() { + return this.getToken(PostgreSQLParser.LARGE_P, 0); +}; + +AlterownerstmtContext.prototype.OBJECT_P = function() { + return this.getToken(PostgreSQLParser.OBJECT_P, 0); +}; + +AlterownerstmtContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +AlterownerstmtContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +AlterownerstmtContext.prototype.operator_with_argtypes = function() { + return this.getTypedRuleContext(Operator_with_argtypesContext,0); +}; + +AlterownerstmtContext.prototype.CLASS = function() { + return this.getToken(PostgreSQLParser.CLASS, 0); +}; + +AlterownerstmtContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +AlterownerstmtContext.prototype.FAMILY = function() { + return this.getToken(PostgreSQLParser.FAMILY, 0); +}; + +AlterownerstmtContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +AlterownerstmtContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +AlterownerstmtContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +AlterownerstmtContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +AlterownerstmtContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +AlterownerstmtContext.prototype.STATISTICS = function() { + return this.getToken(PostgreSQLParser.STATISTICS, 0); +}; + +AlterownerstmtContext.prototype.TEXT_P = function() { + return this.getToken(PostgreSQLParser.TEXT_P, 0); +}; + +AlterownerstmtContext.prototype.SEARCH = function() { + return this.getToken(PostgreSQLParser.SEARCH, 0); +}; + +AlterownerstmtContext.prototype.DICTIONARY = function() { + return this.getToken(PostgreSQLParser.DICTIONARY, 0); +}; + +AlterownerstmtContext.prototype.CONFIGURATION = function() { + return this.getToken(PostgreSQLParser.CONFIGURATION, 0); +}; + +AlterownerstmtContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +AlterownerstmtContext.prototype.DATA_P = function() { + return this.getToken(PostgreSQLParser.DATA_P, 0); +}; + +AlterownerstmtContext.prototype.WRAPPER = function() { + return this.getToken(PostgreSQLParser.WRAPPER, 0); +}; + +AlterownerstmtContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +AlterownerstmtContext.prototype.EVENT = function() { + return this.getToken(PostgreSQLParser.EVENT, 0); +}; + +AlterownerstmtContext.prototype.TRIGGER = function() { + return this.getToken(PostgreSQLParser.TRIGGER, 0); +}; + +AlterownerstmtContext.prototype.PUBLICATION = function() { + return this.getToken(PostgreSQLParser.PUBLICATION, 0); +}; + +AlterownerstmtContext.prototype.SUBSCRIPTION = function() { + return this.getToken(PostgreSQLParser.SUBSCRIPTION, 0); +}; + +AlterownerstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterownerstmt(this); + } +}; + +AlterownerstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterownerstmt(this); + } +}; + +AlterownerstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterownerstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterownerstmtContext = AlterownerstmtContext; + +PostgreSQLParser.prototype.alterownerstmt = function() { + + var localctx = new AlterownerstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 744, PostgreSQLParser.RULE_alterownerstmt); + try { + this.state = 6881; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,316,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 6698; + this.match(PostgreSQLParser.ALTER); + this.state = 6699; + this.match(PostgreSQLParser.AGGREGATE); + this.state = 6700; + this.aggregate_with_argtypes(); + this.state = 6701; + this.match(PostgreSQLParser.OWNER); + this.state = 6702; + this.match(PostgreSQLParser.TO); + this.state = 6703; + this.rolespec(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 6705; + this.match(PostgreSQLParser.ALTER); + this.state = 6706; + this.match(PostgreSQLParser.COLLATION); + this.state = 6707; + this.any_name(); + this.state = 6708; + this.match(PostgreSQLParser.OWNER); + this.state = 6709; + this.match(PostgreSQLParser.TO); + this.state = 6710; + this.rolespec(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 6712; + this.match(PostgreSQLParser.ALTER); + this.state = 6713; + this.match(PostgreSQLParser.CONVERSION_P); + this.state = 6714; + this.any_name(); + this.state = 6715; + this.match(PostgreSQLParser.OWNER); + this.state = 6716; + this.match(PostgreSQLParser.TO); + this.state = 6717; + this.rolespec(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 6719; + this.match(PostgreSQLParser.ALTER); + this.state = 6720; + this.match(PostgreSQLParser.DATABASE); + this.state = 6721; + this.name(); + this.state = 6722; + this.match(PostgreSQLParser.OWNER); + this.state = 6723; + this.match(PostgreSQLParser.TO); + this.state = 6724; + this.rolespec(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 6726; + this.match(PostgreSQLParser.ALTER); + this.state = 6727; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 6728; + this.any_name(); + this.state = 6729; + this.match(PostgreSQLParser.OWNER); + this.state = 6730; + this.match(PostgreSQLParser.TO); + this.state = 6731; + this.rolespec(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 6733; + this.match(PostgreSQLParser.ALTER); + this.state = 6734; + this.match(PostgreSQLParser.FUNCTION); + this.state = 6735; + this.function_with_argtypes(); + this.state = 6736; + this.match(PostgreSQLParser.OWNER); + this.state = 6737; + this.match(PostgreSQLParser.TO); + this.state = 6738; + this.rolespec(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 6740; + this.match(PostgreSQLParser.ALTER); + this.state = 6741; + this.opt_procedural(); + this.state = 6742; + this.match(PostgreSQLParser.LANGUAGE); + this.state = 6743; + this.name(); + this.state = 6744; + this.match(PostgreSQLParser.OWNER); + this.state = 6745; + this.match(PostgreSQLParser.TO); + this.state = 6746; + this.rolespec(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 6748; + this.match(PostgreSQLParser.ALTER); + this.state = 6749; + this.match(PostgreSQLParser.LARGE_P); + this.state = 6750; + this.match(PostgreSQLParser.OBJECT_P); + this.state = 6751; + this.numericonly(); + this.state = 6752; + this.match(PostgreSQLParser.OWNER); + this.state = 6753; + this.match(PostgreSQLParser.TO); + this.state = 6754; + this.rolespec(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 6756; + this.match(PostgreSQLParser.ALTER); + this.state = 6757; + this.match(PostgreSQLParser.OPERATOR); + this.state = 6758; + this.operator_with_argtypes(); + this.state = 6759; + this.match(PostgreSQLParser.OWNER); + this.state = 6760; + this.match(PostgreSQLParser.TO); + this.state = 6761; + this.rolespec(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 6763; + this.match(PostgreSQLParser.ALTER); + this.state = 6764; + this.match(PostgreSQLParser.OPERATOR); + this.state = 6765; + this.match(PostgreSQLParser.CLASS); + this.state = 6766; + this.any_name(); + this.state = 6767; + this.match(PostgreSQLParser.USING); + this.state = 6768; + this.name(); + this.state = 6769; + this.match(PostgreSQLParser.OWNER); + this.state = 6770; + this.match(PostgreSQLParser.TO); + this.state = 6771; + this.rolespec(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 6773; + this.match(PostgreSQLParser.ALTER); + this.state = 6774; + this.match(PostgreSQLParser.OPERATOR); + this.state = 6775; + this.match(PostgreSQLParser.FAMILY); + this.state = 6776; + this.any_name(); + this.state = 6777; + this.match(PostgreSQLParser.USING); + this.state = 6778; + this.name(); + this.state = 6779; + this.match(PostgreSQLParser.OWNER); + this.state = 6780; + this.match(PostgreSQLParser.TO); + this.state = 6781; + this.rolespec(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 6783; + this.match(PostgreSQLParser.ALTER); + this.state = 6784; + this.match(PostgreSQLParser.PROCEDURE); + this.state = 6785; + this.function_with_argtypes(); + this.state = 6786; + this.match(PostgreSQLParser.OWNER); + this.state = 6787; + this.match(PostgreSQLParser.TO); + this.state = 6788; + this.rolespec(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 6790; + this.match(PostgreSQLParser.ALTER); + this.state = 6791; + this.match(PostgreSQLParser.ROUTINE); + this.state = 6792; + this.function_with_argtypes(); + this.state = 6793; + this.match(PostgreSQLParser.OWNER); + this.state = 6794; + this.match(PostgreSQLParser.TO); + this.state = 6795; + this.rolespec(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 6797; + this.match(PostgreSQLParser.ALTER); + this.state = 6798; + this.match(PostgreSQLParser.SCHEMA); + this.state = 6799; + this.name(); + this.state = 6800; + this.match(PostgreSQLParser.OWNER); + this.state = 6801; + this.match(PostgreSQLParser.TO); + this.state = 6802; + this.rolespec(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 6804; + this.match(PostgreSQLParser.ALTER); + this.state = 6805; + this.match(PostgreSQLParser.TYPE_P); + this.state = 6806; + this.any_name(); + this.state = 6807; + this.match(PostgreSQLParser.OWNER); + this.state = 6808; + this.match(PostgreSQLParser.TO); + this.state = 6809; + this.rolespec(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 6811; + this.match(PostgreSQLParser.ALTER); + this.state = 6812; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 6813; + this.name(); + this.state = 6814; + this.match(PostgreSQLParser.OWNER); + this.state = 6815; + this.match(PostgreSQLParser.TO); + this.state = 6816; + this.rolespec(); + break; + + case 17: + this.enterOuterAlt(localctx, 17); + this.state = 6818; + this.match(PostgreSQLParser.ALTER); + this.state = 6819; + this.match(PostgreSQLParser.STATISTICS); + this.state = 6820; + this.any_name(); + this.state = 6821; + this.match(PostgreSQLParser.OWNER); + this.state = 6822; + this.match(PostgreSQLParser.TO); + this.state = 6823; + this.rolespec(); + break; + + case 18: + this.enterOuterAlt(localctx, 18); + this.state = 6825; + this.match(PostgreSQLParser.ALTER); + this.state = 6826; + this.match(PostgreSQLParser.TEXT_P); + this.state = 6827; + this.match(PostgreSQLParser.SEARCH); + this.state = 6828; + this.match(PostgreSQLParser.DICTIONARY); + this.state = 6829; + this.any_name(); + this.state = 6830; + this.match(PostgreSQLParser.OWNER); + this.state = 6831; + this.match(PostgreSQLParser.TO); + this.state = 6832; + this.rolespec(); + break; + + case 19: + this.enterOuterAlt(localctx, 19); + this.state = 6834; + this.match(PostgreSQLParser.ALTER); + this.state = 6835; + this.match(PostgreSQLParser.TEXT_P); + this.state = 6836; + this.match(PostgreSQLParser.SEARCH); + this.state = 6837; + this.match(PostgreSQLParser.CONFIGURATION); + this.state = 6838; + this.any_name(); + this.state = 6839; + this.match(PostgreSQLParser.OWNER); + this.state = 6840; + this.match(PostgreSQLParser.TO); + this.state = 6841; + this.rolespec(); + break; + + case 20: + this.enterOuterAlt(localctx, 20); + this.state = 6843; + this.match(PostgreSQLParser.ALTER); + this.state = 6844; + this.match(PostgreSQLParser.FOREIGN); + this.state = 6845; + this.match(PostgreSQLParser.DATA_P); + this.state = 6846; + this.match(PostgreSQLParser.WRAPPER); + this.state = 6847; + this.name(); + this.state = 6848; + this.match(PostgreSQLParser.OWNER); + this.state = 6849; + this.match(PostgreSQLParser.TO); + this.state = 6850; + this.rolespec(); + break; + + case 21: + this.enterOuterAlt(localctx, 21); + this.state = 6852; + this.match(PostgreSQLParser.ALTER); + this.state = 6853; + this.match(PostgreSQLParser.SERVER); + this.state = 6854; + this.name(); + this.state = 6855; + this.match(PostgreSQLParser.OWNER); + this.state = 6856; + this.match(PostgreSQLParser.TO); + this.state = 6857; + this.rolespec(); + break; + + case 22: + this.enterOuterAlt(localctx, 22); + this.state = 6859; + this.match(PostgreSQLParser.ALTER); + this.state = 6860; + this.match(PostgreSQLParser.EVENT); + this.state = 6861; + this.match(PostgreSQLParser.TRIGGER); + this.state = 6862; + this.name(); + this.state = 6863; + this.match(PostgreSQLParser.OWNER); + this.state = 6864; + this.match(PostgreSQLParser.TO); + this.state = 6865; + this.rolespec(); + break; + + case 23: + this.enterOuterAlt(localctx, 23); + this.state = 6867; + this.match(PostgreSQLParser.ALTER); + this.state = 6868; + this.match(PostgreSQLParser.PUBLICATION); + this.state = 6869; + this.name(); + this.state = 6870; + this.match(PostgreSQLParser.OWNER); + this.state = 6871; + this.match(PostgreSQLParser.TO); + this.state = 6872; + this.rolespec(); + break; + + case 24: + this.enterOuterAlt(localctx, 24); + this.state = 6874; + this.match(PostgreSQLParser.ALTER); + this.state = 6875; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6876; + this.name(); + this.state = 6877; + this.match(PostgreSQLParser.OWNER); + this.state = 6878; + this.match(PostgreSQLParser.TO); + this.state = 6879; + this.rolespec(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatepublicationstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createpublicationstmt; + return this; +} + +CreatepublicationstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatepublicationstmtContext.prototype.constructor = CreatepublicationstmtContext; + +CreatepublicationstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatepublicationstmtContext.prototype.PUBLICATION = function() { + return this.getToken(PostgreSQLParser.PUBLICATION, 0); +}; + +CreatepublicationstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreatepublicationstmtContext.prototype.opt_publication_for_tables = function() { + return this.getTypedRuleContext(Opt_publication_for_tablesContext,0); +}; + +CreatepublicationstmtContext.prototype.opt_definition = function() { + return this.getTypedRuleContext(Opt_definitionContext,0); +}; + +CreatepublicationstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatepublicationstmt(this); + } +}; + +CreatepublicationstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatepublicationstmt(this); + } +}; + +CreatepublicationstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatepublicationstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatepublicationstmtContext = CreatepublicationstmtContext; + +PostgreSQLParser.prototype.createpublicationstmt = function() { + + var localctx = new CreatepublicationstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 746, PostgreSQLParser.RULE_createpublicationstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 6883; + this.match(PostgreSQLParser.CREATE); + this.state = 6884; + this.match(PostgreSQLParser.PUBLICATION); + this.state = 6885; + this.name(); + this.state = 6886; + this.opt_publication_for_tables(); + this.state = 6887; + this.opt_definition(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_publication_for_tablesContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_publication_for_tables; + return this; +} + +Opt_publication_for_tablesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_publication_for_tablesContext.prototype.constructor = Opt_publication_for_tablesContext; + +Opt_publication_for_tablesContext.prototype.publication_for_tables = function() { + return this.getTypedRuleContext(Publication_for_tablesContext,0); +}; + +Opt_publication_for_tablesContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_publication_for_tables(this); + } +}; + +Opt_publication_for_tablesContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_publication_for_tables(this); + } +}; + +Opt_publication_for_tablesContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_publication_for_tables(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_publication_for_tablesContext = Opt_publication_for_tablesContext; + +PostgreSQLParser.prototype.opt_publication_for_tables = function() { + + var localctx = new Opt_publication_for_tablesContext(this, this._ctx, this.state); + this.enterRule(localctx, 748, PostgreSQLParser.RULE_opt_publication_for_tables); + try { + this.state = 6891; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FOR: + this.enterOuterAlt(localctx, 1); + this.state = 6889; + this.publication_for_tables(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Publication_for_tablesContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_publication_for_tables; + return this; +} + +Publication_for_tablesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Publication_for_tablesContext.prototype.constructor = Publication_for_tablesContext; + +Publication_for_tablesContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Publication_for_tablesContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +Publication_for_tablesContext.prototype.relation_expr_list = function() { + return this.getTypedRuleContext(Relation_expr_listContext,0); +}; + +Publication_for_tablesContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Publication_for_tablesContext.prototype.TABLES = function() { + return this.getToken(PostgreSQLParser.TABLES, 0); +}; + +Publication_for_tablesContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPublication_for_tables(this); + } +}; + +Publication_for_tablesContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPublication_for_tables(this); + } +}; + +Publication_for_tablesContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPublication_for_tables(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Publication_for_tablesContext = Publication_for_tablesContext; + +PostgreSQLParser.prototype.publication_for_tables = function() { + + var localctx = new Publication_for_tablesContext(this, this._ctx, this.state); + this.enterRule(localctx, 750, PostgreSQLParser.RULE_publication_for_tables); + try { + this.state = 6899; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,318,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 6893; + this.match(PostgreSQLParser.FOR); + this.state = 6894; + this.match(PostgreSQLParser.TABLE); + this.state = 6895; + this.relation_expr_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 6896; + this.match(PostgreSQLParser.FOR); + this.state = 6897; + this.match(PostgreSQLParser.ALL); + this.state = 6898; + this.match(PostgreSQLParser.TABLES); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterpublicationstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterpublicationstmt; + return this; +} + +AlterpublicationstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterpublicationstmtContext.prototype.constructor = AlterpublicationstmtContext; + +AlterpublicationstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterpublicationstmtContext.prototype.PUBLICATION = function() { + return this.getToken(PostgreSQLParser.PUBLICATION, 0); +}; + +AlterpublicationstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AlterpublicationstmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AlterpublicationstmtContext.prototype.definition = function() { + return this.getTypedRuleContext(DefinitionContext,0); +}; + +AlterpublicationstmtContext.prototype.ADD_P = function() { + return this.getToken(PostgreSQLParser.ADD_P, 0); +}; + +AlterpublicationstmtContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +AlterpublicationstmtContext.prototype.relation_expr_list = function() { + return this.getTypedRuleContext(Relation_expr_listContext,0); +}; + +AlterpublicationstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +AlterpublicationstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterpublicationstmt(this); + } +}; + +AlterpublicationstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterpublicationstmt(this); + } +}; + +AlterpublicationstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterpublicationstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterpublicationstmtContext = AlterpublicationstmtContext; + +PostgreSQLParser.prototype.alterpublicationstmt = function() { + + var localctx = new AlterpublicationstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 752, PostgreSQLParser.RULE_alterpublicationstmt); + try { + this.state = 6928; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,319,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 6901; + this.match(PostgreSQLParser.ALTER); + this.state = 6902; + this.match(PostgreSQLParser.PUBLICATION); + this.state = 6903; + this.name(); + this.state = 6904; + this.match(PostgreSQLParser.SET); + this.state = 6905; + this.definition(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 6907; + this.match(PostgreSQLParser.ALTER); + this.state = 6908; + this.match(PostgreSQLParser.PUBLICATION); + this.state = 6909; + this.name(); + this.state = 6910; + this.match(PostgreSQLParser.ADD_P); + this.state = 6911; + this.match(PostgreSQLParser.TABLE); + this.state = 6912; + this.relation_expr_list(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 6914; + this.match(PostgreSQLParser.ALTER); + this.state = 6915; + this.match(PostgreSQLParser.PUBLICATION); + this.state = 6916; + this.name(); + this.state = 6917; + this.match(PostgreSQLParser.SET); + this.state = 6918; + this.match(PostgreSQLParser.TABLE); + this.state = 6919; + this.relation_expr_list(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 6921; + this.match(PostgreSQLParser.ALTER); + this.state = 6922; + this.match(PostgreSQLParser.PUBLICATION); + this.state = 6923; + this.name(); + this.state = 6924; + this.match(PostgreSQLParser.DROP); + this.state = 6925; + this.match(PostgreSQLParser.TABLE); + this.state = 6926; + this.relation_expr_list(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatesubscriptionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createsubscriptionstmt; + return this; +} + +CreatesubscriptionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatesubscriptionstmtContext.prototype.constructor = CreatesubscriptionstmtContext; + +CreatesubscriptionstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatesubscriptionstmtContext.prototype.SUBSCRIPTION = function() { + return this.getToken(PostgreSQLParser.SUBSCRIPTION, 0); +}; + +CreatesubscriptionstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreatesubscriptionstmtContext.prototype.CONNECTION = function() { + return this.getToken(PostgreSQLParser.CONNECTION, 0); +}; + +CreatesubscriptionstmtContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +CreatesubscriptionstmtContext.prototype.PUBLICATION = function() { + return this.getToken(PostgreSQLParser.PUBLICATION, 0); +}; + +CreatesubscriptionstmtContext.prototype.publication_name_list = function() { + return this.getTypedRuleContext(Publication_name_listContext,0); +}; + +CreatesubscriptionstmtContext.prototype.opt_definition = function() { + return this.getTypedRuleContext(Opt_definitionContext,0); +}; + +CreatesubscriptionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatesubscriptionstmt(this); + } +}; + +CreatesubscriptionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatesubscriptionstmt(this); + } +}; + +CreatesubscriptionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatesubscriptionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatesubscriptionstmtContext = CreatesubscriptionstmtContext; + +PostgreSQLParser.prototype.createsubscriptionstmt = function() { + + var localctx = new CreatesubscriptionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 754, PostgreSQLParser.RULE_createsubscriptionstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 6930; + this.match(PostgreSQLParser.CREATE); + this.state = 6931; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6932; + this.name(); + this.state = 6933; + this.match(PostgreSQLParser.CONNECTION); + this.state = 6934; + this.sconst(); + this.state = 6935; + this.match(PostgreSQLParser.PUBLICATION); + this.state = 6936; + this.publication_name_list(); + this.state = 6937; + this.opt_definition(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Publication_name_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_publication_name_list; + return this; +} + +Publication_name_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Publication_name_listContext.prototype.constructor = Publication_name_listContext; + +Publication_name_listContext.prototype.publication_name_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Publication_name_itemContext); + } else { + return this.getTypedRuleContext(Publication_name_itemContext,i); + } +}; + +Publication_name_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Publication_name_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPublication_name_list(this); + } +}; + +Publication_name_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPublication_name_list(this); + } +}; + +Publication_name_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPublication_name_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Publication_name_listContext = Publication_name_listContext; + +PostgreSQLParser.prototype.publication_name_list = function() { + + var localctx = new Publication_name_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 756, PostgreSQLParser.RULE_publication_name_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 6939; + this.publication_name_item(); + this.state = 6944; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 6940; + this.match(PostgreSQLParser.COMMA); + this.state = 6941; + this.publication_name_item(); + this.state = 6946; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Publication_name_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_publication_name_item; + return this; +} + +Publication_name_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Publication_name_itemContext.prototype.constructor = Publication_name_itemContext; + +Publication_name_itemContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +Publication_name_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPublication_name_item(this); + } +}; + +Publication_name_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPublication_name_item(this); + } +}; + +Publication_name_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPublication_name_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Publication_name_itemContext = Publication_name_itemContext; + +PostgreSQLParser.prototype.publication_name_item = function() { + + var localctx = new Publication_name_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 758, PostgreSQLParser.RULE_publication_name_item); + try { + this.enterOuterAlt(localctx, 1); + this.state = 6947; + this.collabel(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltersubscriptionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altersubscriptionstmt; + return this; +} + +AltersubscriptionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltersubscriptionstmtContext.prototype.constructor = AltersubscriptionstmtContext; + +AltersubscriptionstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AltersubscriptionstmtContext.prototype.SUBSCRIPTION = function() { + return this.getToken(PostgreSQLParser.SUBSCRIPTION, 0); +}; + +AltersubscriptionstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AltersubscriptionstmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AltersubscriptionstmtContext.prototype.definition = function() { + return this.getTypedRuleContext(DefinitionContext,0); +}; + +AltersubscriptionstmtContext.prototype.CONNECTION = function() { + return this.getToken(PostgreSQLParser.CONNECTION, 0); +}; + +AltersubscriptionstmtContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +AltersubscriptionstmtContext.prototype.REFRESH = function() { + return this.getToken(PostgreSQLParser.REFRESH, 0); +}; + +AltersubscriptionstmtContext.prototype.PUBLICATION = function() { + return this.getToken(PostgreSQLParser.PUBLICATION, 0); +}; + +AltersubscriptionstmtContext.prototype.opt_definition = function() { + return this.getTypedRuleContext(Opt_definitionContext,0); +}; + +AltersubscriptionstmtContext.prototype.publication_name_list = function() { + return this.getTypedRuleContext(Publication_name_listContext,0); +}; + +AltersubscriptionstmtContext.prototype.ENABLE_P = function() { + return this.getToken(PostgreSQLParser.ENABLE_P, 0); +}; + +AltersubscriptionstmtContext.prototype.DISABLE_P = function() { + return this.getToken(PostgreSQLParser.DISABLE_P, 0); +}; + +AltersubscriptionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltersubscriptionstmt(this); + } +}; + +AltersubscriptionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltersubscriptionstmt(this); + } +}; + +AltersubscriptionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltersubscriptionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltersubscriptionstmtContext = AltersubscriptionstmtContext; + +PostgreSQLParser.prototype.altersubscriptionstmt = function() { + + var localctx = new AltersubscriptionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 760, PostgreSQLParser.RULE_altersubscriptionstmt); + try { + this.state = 6986; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,321,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 6949; + this.match(PostgreSQLParser.ALTER); + this.state = 6950; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6951; + this.name(); + this.state = 6952; + this.match(PostgreSQLParser.SET); + this.state = 6953; + this.definition(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 6955; + this.match(PostgreSQLParser.ALTER); + this.state = 6956; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6957; + this.name(); + this.state = 6958; + this.match(PostgreSQLParser.CONNECTION); + this.state = 6959; + this.sconst(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 6961; + this.match(PostgreSQLParser.ALTER); + this.state = 6962; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6963; + this.name(); + this.state = 6964; + this.match(PostgreSQLParser.REFRESH); + this.state = 6965; + this.match(PostgreSQLParser.PUBLICATION); + this.state = 6966; + this.opt_definition(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 6968; + this.match(PostgreSQLParser.ALTER); + this.state = 6969; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6970; + this.name(); + this.state = 6971; + this.match(PostgreSQLParser.SET); + this.state = 6972; + this.match(PostgreSQLParser.PUBLICATION); + this.state = 6973; + this.publication_name_list(); + this.state = 6974; + this.opt_definition(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 6976; + this.match(PostgreSQLParser.ALTER); + this.state = 6977; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6978; + this.name(); + this.state = 6979; + this.match(PostgreSQLParser.ENABLE_P); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 6981; + this.match(PostgreSQLParser.ALTER); + this.state = 6982; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6983; + this.name(); + this.state = 6984; + this.match(PostgreSQLParser.DISABLE_P); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DropsubscriptionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dropsubscriptionstmt; + return this; +} + +DropsubscriptionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DropsubscriptionstmtContext.prototype.constructor = DropsubscriptionstmtContext; + +DropsubscriptionstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DropsubscriptionstmtContext.prototype.SUBSCRIPTION = function() { + return this.getToken(PostgreSQLParser.SUBSCRIPTION, 0); +}; + +DropsubscriptionstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +DropsubscriptionstmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +DropsubscriptionstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +DropsubscriptionstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +DropsubscriptionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDropsubscriptionstmt(this); + } +}; + +DropsubscriptionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDropsubscriptionstmt(this); + } +}; + +DropsubscriptionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDropsubscriptionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DropsubscriptionstmtContext = DropsubscriptionstmtContext; + +PostgreSQLParser.prototype.dropsubscriptionstmt = function() { + + var localctx = new DropsubscriptionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 762, PostgreSQLParser.RULE_dropsubscriptionstmt); + try { + this.state = 7000; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,322,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 6988; + this.match(PostgreSQLParser.DROP); + this.state = 6989; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6990; + this.name(); + this.state = 6991; + this.opt_drop_behavior(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 6993; + this.match(PostgreSQLParser.DROP); + this.state = 6994; + this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 6995; + this.match(PostgreSQLParser.IF_P); + this.state = 6996; + this.match(PostgreSQLParser.EXISTS); + this.state = 6997; + this.name(); + this.state = 6998; + this.opt_drop_behavior(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RulestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rulestmt; + return this; +} + +RulestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RulestmtContext.prototype.constructor = RulestmtContext; + +RulestmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +RulestmtContext.prototype.opt_or_replace = function() { + return this.getTypedRuleContext(Opt_or_replaceContext,0); +}; + +RulestmtContext.prototype.RULE = function() { + return this.getToken(PostgreSQLParser.RULE, 0); +}; + +RulestmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +RulestmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +RulestmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +RulestmtContext.prototype.event = function() { + return this.getTypedRuleContext(EventContext,0); +}; + +RulestmtContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +RulestmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +RulestmtContext.prototype.where_clause = function() { + return this.getTypedRuleContext(Where_clauseContext,0); +}; + +RulestmtContext.prototype.DO = function() { + return this.getToken(PostgreSQLParser.DO, 0); +}; + +RulestmtContext.prototype.opt_instead = function() { + return this.getTypedRuleContext(Opt_insteadContext,0); +}; + +RulestmtContext.prototype.ruleactionlist = function() { + return this.getTypedRuleContext(RuleactionlistContext,0); +}; + +RulestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRulestmt(this); + } +}; + +RulestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRulestmt(this); + } +}; + +RulestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRulestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RulestmtContext = RulestmtContext; + +PostgreSQLParser.prototype.rulestmt = function() { + + var localctx = new RulestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 764, PostgreSQLParser.RULE_rulestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7002; + this.match(PostgreSQLParser.CREATE); + this.state = 7003; + this.opt_or_replace(); + this.state = 7004; + this.match(PostgreSQLParser.RULE); + this.state = 7005; + this.name(); + this.state = 7006; + this.match(PostgreSQLParser.AS); + this.state = 7007; + this.match(PostgreSQLParser.ON); + this.state = 7008; + this.event(); + this.state = 7009; + this.match(PostgreSQLParser.TO); + this.state = 7010; + this.qualified_name(); + this.state = 7011; + this.where_clause(); + this.state = 7012; + this.match(PostgreSQLParser.DO); + this.state = 7013; + this.opt_instead(); + this.state = 7014; + this.ruleactionlist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RuleactionlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_ruleactionlist; + return this; +} + +RuleactionlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RuleactionlistContext.prototype.constructor = RuleactionlistContext; + +RuleactionlistContext.prototype.NOTHING = function() { + return this.getToken(PostgreSQLParser.NOTHING, 0); +}; + +RuleactionlistContext.prototype.ruleactionstmt = function() { + return this.getTypedRuleContext(RuleactionstmtContext,0); +}; + +RuleactionlistContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +RuleactionlistContext.prototype.ruleactionmulti = function() { + return this.getTypedRuleContext(RuleactionmultiContext,0); +}; + +RuleactionlistContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +RuleactionlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRuleactionlist(this); + } +}; + +RuleactionlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRuleactionlist(this); + } +}; + +RuleactionlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRuleactionlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RuleactionlistContext = RuleactionlistContext; + +PostgreSQLParser.prototype.ruleactionlist = function() { + + var localctx = new RuleactionlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 766, PostgreSQLParser.RULE_ruleactionlist); + try { + this.state = 7022; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,323,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7016; + this.match(PostgreSQLParser.NOTHING); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7017; + this.ruleactionstmt(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7018; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7019; + this.ruleactionmulti(); + this.state = 7020; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RuleactionmultiContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_ruleactionmulti; + return this; +} + +RuleactionmultiContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RuleactionmultiContext.prototype.constructor = RuleactionmultiContext; + +RuleactionmultiContext.prototype.ruleactionstmtOrEmpty = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(RuleactionstmtOrEmptyContext); + } else { + return this.getTypedRuleContext(RuleactionstmtOrEmptyContext,i); + } +}; + +RuleactionmultiContext.prototype.SEMI = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.SEMI); + } else { + return this.getToken(PostgreSQLParser.SEMI, i); + } +}; + + +RuleactionmultiContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRuleactionmulti(this); + } +}; + +RuleactionmultiContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRuleactionmulti(this); + } +}; + +RuleactionmultiContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRuleactionmulti(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RuleactionmultiContext = RuleactionmultiContext; + +PostgreSQLParser.prototype.ruleactionmulti = function() { + + var localctx = new RuleactionmultiContext(this, this._ctx, this.state); + this.enterRule(localctx, 768, PostgreSQLParser.RULE_ruleactionmulti); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7024; + this.ruleactionstmtOrEmpty(); + this.state = 7029; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.SEMI) { + this.state = 7025; + this.match(PostgreSQLParser.SEMI); + this.state = 7026; + this.ruleactionstmtOrEmpty(); + this.state = 7031; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RuleactionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_ruleactionstmt; + return this; +} + +RuleactionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RuleactionstmtContext.prototype.constructor = RuleactionstmtContext; + +RuleactionstmtContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +RuleactionstmtContext.prototype.insertstmt = function() { + return this.getTypedRuleContext(InsertstmtContext,0); +}; + +RuleactionstmtContext.prototype.updatestmt = function() { + return this.getTypedRuleContext(UpdatestmtContext,0); +}; + +RuleactionstmtContext.prototype.deletestmt = function() { + return this.getTypedRuleContext(DeletestmtContext,0); +}; + +RuleactionstmtContext.prototype.notifystmt = function() { + return this.getTypedRuleContext(NotifystmtContext,0); +}; + +RuleactionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRuleactionstmt(this); + } +}; + +RuleactionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRuleactionstmt(this); + } +}; + +RuleactionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRuleactionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RuleactionstmtContext = RuleactionstmtContext; + +PostgreSQLParser.prototype.ruleactionstmt = function() { + + var localctx = new RuleactionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 770, PostgreSQLParser.RULE_ruleactionstmt); + try { + this.state = 7037; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,325,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7032; + this.selectstmt(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7033; + this.insertstmt(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7034; + this.updatestmt(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 7035; + this.deletestmt(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 7036; + this.notifystmt(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RuleactionstmtOrEmptyContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_ruleactionstmtOrEmpty; + return this; +} + +RuleactionstmtOrEmptyContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RuleactionstmtOrEmptyContext.prototype.constructor = RuleactionstmtOrEmptyContext; + +RuleactionstmtOrEmptyContext.prototype.ruleactionstmt = function() { + return this.getTypedRuleContext(RuleactionstmtContext,0); +}; + +RuleactionstmtOrEmptyContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRuleactionstmtOrEmpty(this); + } +}; + +RuleactionstmtOrEmptyContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRuleactionstmtOrEmpty(this); + } +}; + +RuleactionstmtOrEmptyContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRuleactionstmtOrEmpty(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RuleactionstmtOrEmptyContext = RuleactionstmtOrEmptyContext; + +PostgreSQLParser.prototype.ruleactionstmtOrEmpty = function() { + + var localctx = new RuleactionstmtOrEmptyContext(this, this._ctx, this.state); + this.enterRule(localctx, 772, PostgreSQLParser.RULE_ruleactionstmtOrEmpty); + try { + this.state = 7041; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VALUES: + this.enterOuterAlt(localctx, 1); + this.state = 7039; + this.ruleactionstmt(); + break; + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function EventContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_event; + return this; +} + +EventContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +EventContext.prototype.constructor = EventContext; + +EventContext.prototype.SELECT = function() { + return this.getToken(PostgreSQLParser.SELECT, 0); +}; + +EventContext.prototype.UPDATE = function() { + return this.getToken(PostgreSQLParser.UPDATE, 0); +}; + +EventContext.prototype.DELETE_P = function() { + return this.getToken(PostgreSQLParser.DELETE_P, 0); +}; + +EventContext.prototype.INSERT = function() { + return this.getToken(PostgreSQLParser.INSERT, 0); +}; + +EventContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterEvent(this); + } +}; + +EventContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitEvent(this); + } +}; + +EventContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitEvent(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.EventContext = EventContext; + +PostgreSQLParser.prototype.event = function() { + + var localctx = new EventContext(this, this._ctx, this.state); + this.enterRule(localctx, 774, PostgreSQLParser.RULE_event); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7043; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.SELECT || _la===PostgreSQLParser.DELETE_P || _la===PostgreSQLParser.INSERT || _la===PostgreSQLParser.UPDATE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_insteadContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_instead; + return this; +} + +Opt_insteadContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_insteadContext.prototype.constructor = Opt_insteadContext; + +Opt_insteadContext.prototype.INSTEAD = function() { + return this.getToken(PostgreSQLParser.INSTEAD, 0); +}; + +Opt_insteadContext.prototype.ALSO = function() { + return this.getToken(PostgreSQLParser.ALSO, 0); +}; + +Opt_insteadContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_instead(this); + } +}; + +Opt_insteadContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_instead(this); + } +}; + +Opt_insteadContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_instead(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_insteadContext = Opt_insteadContext; + +PostgreSQLParser.prototype.opt_instead = function() { + + var localctx = new Opt_insteadContext(this, this._ctx, this.state); + this.enterRule(localctx, 776, PostgreSQLParser.RULE_opt_instead); + try { + this.state = 7048; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.INSTEAD: + this.enterOuterAlt(localctx, 1); + this.state = 7045; + this.match(PostgreSQLParser.INSTEAD); + break; + case PostgreSQLParser.ALSO: + this.enterOuterAlt(localctx, 2); + this.state = 7046; + this.match(PostgreSQLParser.ALSO); + break; + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VALUES: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function NotifystmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_notifystmt; + return this; +} + +NotifystmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +NotifystmtContext.prototype.constructor = NotifystmtContext; + +NotifystmtContext.prototype.NOTIFY = function() { + return this.getToken(PostgreSQLParser.NOTIFY, 0); +}; + +NotifystmtContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +NotifystmtContext.prototype.notify_payload = function() { + return this.getTypedRuleContext(Notify_payloadContext,0); +}; + +NotifystmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterNotifystmt(this); + } +}; + +NotifystmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitNotifystmt(this); + } +}; + +NotifystmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitNotifystmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.NotifystmtContext = NotifystmtContext; + +PostgreSQLParser.prototype.notifystmt = function() { + + var localctx = new NotifystmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 778, PostgreSQLParser.RULE_notifystmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7050; + this.match(PostgreSQLParser.NOTIFY); + this.state = 7051; + this.colid(); + this.state = 7052; + this.notify_payload(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Notify_payloadContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_notify_payload; + return this; +} + +Notify_payloadContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Notify_payloadContext.prototype.constructor = Notify_payloadContext; + +Notify_payloadContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +Notify_payloadContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Notify_payloadContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterNotify_payload(this); + } +}; + +Notify_payloadContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitNotify_payload(this); + } +}; + +Notify_payloadContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitNotify_payload(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Notify_payloadContext = Notify_payloadContext; + +PostgreSQLParser.prototype.notify_payload = function() { + + var localctx = new Notify_payloadContext(this, this._ctx, this.state); + this.enterRule(localctx, 780, PostgreSQLParser.RULE_notify_payload); + try { + this.state = 7057; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.COMMA: + this.enterOuterAlt(localctx, 1); + this.state = 7054; + this.match(PostgreSQLParser.COMMA); + this.state = 7055; + this.sconst(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ListenstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_listenstmt; + return this; +} + +ListenstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ListenstmtContext.prototype.constructor = ListenstmtContext; + +ListenstmtContext.prototype.LISTEN = function() { + return this.getToken(PostgreSQLParser.LISTEN, 0); +}; + +ListenstmtContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +ListenstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterListenstmt(this); + } +}; + +ListenstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitListenstmt(this); + } +}; + +ListenstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitListenstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ListenstmtContext = ListenstmtContext; + +PostgreSQLParser.prototype.listenstmt = function() { + + var localctx = new ListenstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 782, PostgreSQLParser.RULE_listenstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7059; + this.match(PostgreSQLParser.LISTEN); + this.state = 7060; + this.colid(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function UnlistenstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_unlistenstmt; + return this; +} + +UnlistenstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +UnlistenstmtContext.prototype.constructor = UnlistenstmtContext; + +UnlistenstmtContext.prototype.UNLISTEN = function() { + return this.getToken(PostgreSQLParser.UNLISTEN, 0); +}; + +UnlistenstmtContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +UnlistenstmtContext.prototype.STAR = function() { + return this.getToken(PostgreSQLParser.STAR, 0); +}; + +UnlistenstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterUnlistenstmt(this); + } +}; + +UnlistenstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitUnlistenstmt(this); + } +}; + +UnlistenstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitUnlistenstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.UnlistenstmtContext = UnlistenstmtContext; + +PostgreSQLParser.prototype.unlistenstmt = function() { + + var localctx = new UnlistenstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 784, PostgreSQLParser.RULE_unlistenstmt); + try { + this.state = 7066; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,329,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7062; + this.match(PostgreSQLParser.UNLISTEN); + this.state = 7063; + this.colid(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7064; + this.match(PostgreSQLParser.UNLISTEN); + this.state = 7065; + this.match(PostgreSQLParser.STAR); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TransactionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_transactionstmt; + return this; +} + +TransactionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TransactionstmtContext.prototype.constructor = TransactionstmtContext; + +TransactionstmtContext.prototype.ABORT_P = function() { + return this.getToken(PostgreSQLParser.ABORT_P, 0); +}; + +TransactionstmtContext.prototype.opt_transaction = function() { + return this.getTypedRuleContext(Opt_transactionContext,0); +}; + +TransactionstmtContext.prototype.opt_transaction_chain = function() { + return this.getTypedRuleContext(Opt_transaction_chainContext,0); +}; + +TransactionstmtContext.prototype.BEGIN_P = function() { + return this.getToken(PostgreSQLParser.BEGIN_P, 0); +}; + +TransactionstmtContext.prototype.transaction_mode_list_or_empty = function() { + return this.getTypedRuleContext(Transaction_mode_list_or_emptyContext,0); +}; + +TransactionstmtContext.prototype.START = function() { + return this.getToken(PostgreSQLParser.START, 0); +}; + +TransactionstmtContext.prototype.TRANSACTION = function() { + return this.getToken(PostgreSQLParser.TRANSACTION, 0); +}; + +TransactionstmtContext.prototype.COMMIT = function() { + return this.getToken(PostgreSQLParser.COMMIT, 0); +}; + +TransactionstmtContext.prototype.END_P = function() { + return this.getToken(PostgreSQLParser.END_P, 0); +}; + +TransactionstmtContext.prototype.ROLLBACK = function() { + return this.getToken(PostgreSQLParser.ROLLBACK, 0); +}; + +TransactionstmtContext.prototype.SAVEPOINT = function() { + return this.getToken(PostgreSQLParser.SAVEPOINT, 0); +}; + +TransactionstmtContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +TransactionstmtContext.prototype.RELEASE = function() { + return this.getToken(PostgreSQLParser.RELEASE, 0); +}; + +TransactionstmtContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +TransactionstmtContext.prototype.PREPARE = function() { + return this.getToken(PostgreSQLParser.PREPARE, 0); +}; + +TransactionstmtContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +TransactionstmtContext.prototype.PREPARED = function() { + return this.getToken(PostgreSQLParser.PREPARED, 0); +}; + +TransactionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTransactionstmt(this); + } +}; + +TransactionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTransactionstmt(this); + } +}; + +TransactionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTransactionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TransactionstmtContext = TransactionstmtContext; + +PostgreSQLParser.prototype.transactionstmt = function() { + + var localctx = new TransactionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 786, PostgreSQLParser.RULE_transactionstmt); + try { + this.state = 7118; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,330,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7068; + this.match(PostgreSQLParser.ABORT_P); + this.state = 7069; + this.opt_transaction(); + this.state = 7070; + this.opt_transaction_chain(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7072; + this.match(PostgreSQLParser.BEGIN_P); + this.state = 7073; + this.opt_transaction(); + this.state = 7074; + this.transaction_mode_list_or_empty(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7076; + this.match(PostgreSQLParser.START); + this.state = 7077; + this.match(PostgreSQLParser.TRANSACTION); + this.state = 7078; + this.transaction_mode_list_or_empty(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 7079; + this.match(PostgreSQLParser.COMMIT); + this.state = 7080; + this.opt_transaction(); + this.state = 7081; + this.opt_transaction_chain(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 7083; + this.match(PostgreSQLParser.END_P); + this.state = 7084; + this.opt_transaction(); + this.state = 7085; + this.opt_transaction_chain(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 7087; + this.match(PostgreSQLParser.ROLLBACK); + this.state = 7088; + this.opt_transaction(); + this.state = 7089; + this.opt_transaction_chain(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 7091; + this.match(PostgreSQLParser.SAVEPOINT); + this.state = 7092; + this.colid(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 7093; + this.match(PostgreSQLParser.RELEASE); + this.state = 7094; + this.match(PostgreSQLParser.SAVEPOINT); + this.state = 7095; + this.colid(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 7096; + this.match(PostgreSQLParser.RELEASE); + this.state = 7097; + this.colid(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 7098; + this.match(PostgreSQLParser.ROLLBACK); + this.state = 7099; + this.opt_transaction(); + this.state = 7100; + this.match(PostgreSQLParser.TO); + this.state = 7101; + this.match(PostgreSQLParser.SAVEPOINT); + this.state = 7102; + this.colid(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 7104; + this.match(PostgreSQLParser.ROLLBACK); + this.state = 7105; + this.opt_transaction(); + this.state = 7106; + this.match(PostgreSQLParser.TO); + this.state = 7107; + this.colid(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 7109; + this.match(PostgreSQLParser.PREPARE); + this.state = 7110; + this.match(PostgreSQLParser.TRANSACTION); + this.state = 7111; + this.sconst(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 7112; + this.match(PostgreSQLParser.COMMIT); + this.state = 7113; + this.match(PostgreSQLParser.PREPARED); + this.state = 7114; + this.sconst(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 7115; + this.match(PostgreSQLParser.ROLLBACK); + this.state = 7116; + this.match(PostgreSQLParser.PREPARED); + this.state = 7117; + this.sconst(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_transactionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_transaction; + return this; +} + +Opt_transactionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_transactionContext.prototype.constructor = Opt_transactionContext; + +Opt_transactionContext.prototype.WORK = function() { + return this.getToken(PostgreSQLParser.WORK, 0); +}; + +Opt_transactionContext.prototype.TRANSACTION = function() { + return this.getToken(PostgreSQLParser.TRANSACTION, 0); +}; + +Opt_transactionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_transaction(this); + } +}; + +Opt_transactionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_transaction(this); + } +}; + +Opt_transactionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_transaction(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_transactionContext = Opt_transactionContext; + +PostgreSQLParser.prototype.opt_transaction = function() { + + var localctx = new Opt_transactionContext(this, this._ctx, this.state); + this.enterRule(localctx, 788, PostgreSQLParser.RULE_opt_transaction); + try { + this.state = 7123; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.WORK: + this.enterOuterAlt(localctx, 1); + this.state = 7120; + this.match(PostgreSQLParser.WORK); + break; + case PostgreSQLParser.TRANSACTION: + this.enterOuterAlt(localctx, 2); + this.state = 7121; + this.match(PostgreSQLParser.TRANSACTION); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AND: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.NOT: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TO: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Transaction_mode_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_transaction_mode_item; + return this; +} + +Transaction_mode_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Transaction_mode_itemContext.prototype.constructor = Transaction_mode_itemContext; + +Transaction_mode_itemContext.prototype.ISOLATION = function() { + return this.getToken(PostgreSQLParser.ISOLATION, 0); +}; + +Transaction_mode_itemContext.prototype.LEVEL = function() { + return this.getToken(PostgreSQLParser.LEVEL, 0); +}; + +Transaction_mode_itemContext.prototype.iso_level = function() { + return this.getTypedRuleContext(Iso_levelContext,0); +}; + +Transaction_mode_itemContext.prototype.READ = function() { + return this.getToken(PostgreSQLParser.READ, 0); +}; + +Transaction_mode_itemContext.prototype.ONLY = function() { + return this.getToken(PostgreSQLParser.ONLY, 0); +}; + +Transaction_mode_itemContext.prototype.WRITE = function() { + return this.getToken(PostgreSQLParser.WRITE, 0); +}; + +Transaction_mode_itemContext.prototype.DEFERRABLE = function() { + return this.getToken(PostgreSQLParser.DEFERRABLE, 0); +}; + +Transaction_mode_itemContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +Transaction_mode_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTransaction_mode_item(this); + } +}; + +Transaction_mode_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTransaction_mode_item(this); + } +}; + +Transaction_mode_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTransaction_mode_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Transaction_mode_itemContext = Transaction_mode_itemContext; + +PostgreSQLParser.prototype.transaction_mode_item = function() { + + var localctx = new Transaction_mode_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 790, PostgreSQLParser.RULE_transaction_mode_item); + try { + this.state = 7135; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,332,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7125; + this.match(PostgreSQLParser.ISOLATION); + this.state = 7126; + this.match(PostgreSQLParser.LEVEL); + this.state = 7127; + this.iso_level(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7128; + this.match(PostgreSQLParser.READ); + this.state = 7129; + this.match(PostgreSQLParser.ONLY); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7130; + this.match(PostgreSQLParser.READ); + this.state = 7131; + this.match(PostgreSQLParser.WRITE); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 7132; + this.match(PostgreSQLParser.DEFERRABLE); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 7133; + this.match(PostgreSQLParser.NOT); + this.state = 7134; + this.match(PostgreSQLParser.DEFERRABLE); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Transaction_mode_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_transaction_mode_list; + return this; +} + +Transaction_mode_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Transaction_mode_listContext.prototype.constructor = Transaction_mode_listContext; + +Transaction_mode_listContext.prototype.transaction_mode_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Transaction_mode_itemContext); + } else { + return this.getTypedRuleContext(Transaction_mode_itemContext,i); + } +}; + +Transaction_mode_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Transaction_mode_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTransaction_mode_list(this); + } +}; + +Transaction_mode_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTransaction_mode_list(this); + } +}; + +Transaction_mode_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTransaction_mode_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Transaction_mode_listContext = Transaction_mode_listContext; + +PostgreSQLParser.prototype.transaction_mode_list = function() { + + var localctx = new Transaction_mode_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 792, PostgreSQLParser.RULE_transaction_mode_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7137; + this.transaction_mode_item(); + this.state = 7144; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA || _la===PostgreSQLParser.DEFERRABLE || _la===PostgreSQLParser.NOT || _la===PostgreSQLParser.ISOLATION || _la===PostgreSQLParser.READ) { + this.state = 7139; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.COMMA) { + this.state = 7138; + this.match(PostgreSQLParser.COMMA); + } + + this.state = 7141; + this.transaction_mode_item(); + this.state = 7146; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Transaction_mode_list_or_emptyContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_transaction_mode_list_or_empty; + return this; +} + +Transaction_mode_list_or_emptyContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Transaction_mode_list_or_emptyContext.prototype.constructor = Transaction_mode_list_or_emptyContext; + +Transaction_mode_list_or_emptyContext.prototype.transaction_mode_list = function() { + return this.getTypedRuleContext(Transaction_mode_listContext,0); +}; + +Transaction_mode_list_or_emptyContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTransaction_mode_list_or_empty(this); + } +}; + +Transaction_mode_list_or_emptyContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTransaction_mode_list_or_empty(this); + } +}; + +Transaction_mode_list_or_emptyContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTransaction_mode_list_or_empty(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Transaction_mode_list_or_emptyContext = Transaction_mode_list_or_emptyContext; + +PostgreSQLParser.prototype.transaction_mode_list_or_empty = function() { + + var localctx = new Transaction_mode_list_or_emptyContext(this, this._ctx, this.state); + this.enterRule(localctx, 794, PostgreSQLParser.RULE_transaction_mode_list_or_empty); + try { + this.state = 7149; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.NOT: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.READ: + this.enterOuterAlt(localctx, 1); + this.state = 7147; + this.transaction_mode_list(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_transaction_chainContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_transaction_chain; + return this; +} + +Opt_transaction_chainContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_transaction_chainContext.prototype.constructor = Opt_transaction_chainContext; + +Opt_transaction_chainContext.prototype.AND = function() { + return this.getToken(PostgreSQLParser.AND, 0); +}; + +Opt_transaction_chainContext.prototype.CHAIN = function() { + return this.getToken(PostgreSQLParser.CHAIN, 0); +}; + +Opt_transaction_chainContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Opt_transaction_chainContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_transaction_chain(this); + } +}; + +Opt_transaction_chainContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_transaction_chain(this); + } +}; + +Opt_transaction_chainContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_transaction_chain(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_transaction_chainContext = Opt_transaction_chainContext; + +PostgreSQLParser.prototype.opt_transaction_chain = function() { + + var localctx = new Opt_transaction_chainContext(this, this._ctx, this.state); + this.enterRule(localctx, 796, PostgreSQLParser.RULE_opt_transaction_chain); + var _la = 0; // Token type + try { + this.state = 7157; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + this.enterOuterAlt(localctx, 1); + this.state = 7151; + this.match(PostgreSQLParser.AND); + this.state = 7153; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.NO) { + this.state = 7152; + this.match(PostgreSQLParser.NO); + } + + this.state = 7155; + this.match(PostgreSQLParser.CHAIN); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ViewstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_viewstmt; + return this; +} + +ViewstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ViewstmtContext.prototype.constructor = ViewstmtContext; + +ViewstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +ViewstmtContext.prototype.opttemp = function() { + return this.getTypedRuleContext(OpttempContext,0); +}; + +ViewstmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +ViewstmtContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +ViewstmtContext.prototype.opt_check_option = function() { + return this.getTypedRuleContext(Opt_check_optionContext,0); +}; + +ViewstmtContext.prototype.VIEW = function() { + return this.getToken(PostgreSQLParser.VIEW, 0); +}; + +ViewstmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +ViewstmtContext.prototype.opt_column_list = function() { + return this.getTypedRuleContext(Opt_column_listContext,0); +}; + +ViewstmtContext.prototype.opt_reloptions = function() { + return this.getTypedRuleContext(Opt_reloptionsContext,0); +}; + +ViewstmtContext.prototype.RECURSIVE = function() { + return this.getToken(PostgreSQLParser.RECURSIVE, 0); +}; + +ViewstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +ViewstmtContext.prototype.columnlist = function() { + return this.getTypedRuleContext(ColumnlistContext,0); +}; + +ViewstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +ViewstmtContext.prototype.OR = function() { + return this.getToken(PostgreSQLParser.OR, 0); +}; + +ViewstmtContext.prototype.REPLACE = function() { + return this.getToken(PostgreSQLParser.REPLACE, 0); +}; + +ViewstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterViewstmt(this); + } +}; + +ViewstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitViewstmt(this); + } +}; + +ViewstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitViewstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ViewstmtContext = ViewstmtContext; + +PostgreSQLParser.prototype.viewstmt = function() { + + var localctx = new ViewstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 798, PostgreSQLParser.RULE_viewstmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7159; + this.match(PostgreSQLParser.CREATE); + this.state = 7162; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OR) { + this.state = 7160; + this.match(PostgreSQLParser.OR); + this.state = 7161; + this.match(PostgreSQLParser.REPLACE); + } + + this.state = 7164; + this.opttemp(); + this.state = 7178; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.VIEW: + this.state = 7165; + this.match(PostgreSQLParser.VIEW); + this.state = 7166; + this.qualified_name(); + this.state = 7167; + this.opt_column_list(); + this.state = 7168; + this.opt_reloptions(); + break; + case PostgreSQLParser.RECURSIVE: + this.state = 7170; + this.match(PostgreSQLParser.RECURSIVE); + this.state = 7171; + this.match(PostgreSQLParser.VIEW); + this.state = 7172; + this.qualified_name(); + this.state = 7173; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7174; + this.columnlist(); + this.state = 7175; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 7176; + this.opt_reloptions(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 7180; + this.match(PostgreSQLParser.AS); + this.state = 7181; + this.selectstmt(); + this.state = 7182; + this.opt_check_option(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_check_optionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_check_option; + return this; +} + +Opt_check_optionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_check_optionContext.prototype.constructor = Opt_check_optionContext; + +Opt_check_optionContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Opt_check_optionContext.prototype.CHECK = function() { + return this.getToken(PostgreSQLParser.CHECK, 0); +}; + +Opt_check_optionContext.prototype.OPTION = function() { + return this.getToken(PostgreSQLParser.OPTION, 0); +}; + +Opt_check_optionContext.prototype.CASCADED = function() { + return this.getToken(PostgreSQLParser.CASCADED, 0); +}; + +Opt_check_optionContext.prototype.LOCAL = function() { + return this.getToken(PostgreSQLParser.LOCAL, 0); +}; + +Opt_check_optionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_check_option(this); + } +}; + +Opt_check_optionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_check_option(this); + } +}; + +Opt_check_optionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_check_option(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_check_optionContext = Opt_check_optionContext; + +PostgreSQLParser.prototype.opt_check_option = function() { + + var localctx = new Opt_check_optionContext(this, this._ctx, this.state); + this.enterRule(localctx, 800, PostgreSQLParser.RULE_opt_check_option); + var _la = 0; // Token type + try { + this.state = 7191; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,341,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7184; + this.match(PostgreSQLParser.WITH); + this.state = 7186; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.CASCADED || _la===PostgreSQLParser.LOCAL) { + this.state = 7185; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.CASCADED || _la===PostgreSQLParser.LOCAL)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } + + this.state = 7188; + this.match(PostgreSQLParser.CHECK); + this.state = 7189; + this.match(PostgreSQLParser.OPTION); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function LoadstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_loadstmt; + return this; +} + +LoadstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +LoadstmtContext.prototype.constructor = LoadstmtContext; + +LoadstmtContext.prototype.LOAD = function() { + return this.getToken(PostgreSQLParser.LOAD, 0); +}; + +LoadstmtContext.prototype.file_name = function() { + return this.getTypedRuleContext(File_nameContext,0); +}; + +LoadstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterLoadstmt(this); + } +}; + +LoadstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitLoadstmt(this); + } +}; + +LoadstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitLoadstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.LoadstmtContext = LoadstmtContext; + +PostgreSQLParser.prototype.loadstmt = function() { + + var localctx = new LoadstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 802, PostgreSQLParser.RULE_loadstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7193; + this.match(PostgreSQLParser.LOAD); + this.state = 7194; + this.file_name(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatedbstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createdbstmt; + return this; +} + +CreatedbstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatedbstmtContext.prototype.constructor = CreatedbstmtContext; + +CreatedbstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatedbstmtContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +CreatedbstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +CreatedbstmtContext.prototype.opt_with = function() { + return this.getTypedRuleContext(Opt_withContext,0); +}; + +CreatedbstmtContext.prototype.createdb_opt_list = function() { + return this.getTypedRuleContext(Createdb_opt_listContext,0); +}; + +CreatedbstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatedbstmt(this); + } +}; + +CreatedbstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatedbstmt(this); + } +}; + +CreatedbstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatedbstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatedbstmtContext = CreatedbstmtContext; + +PostgreSQLParser.prototype.createdbstmt = function() { + + var localctx = new CreatedbstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 804, PostgreSQLParser.RULE_createdbstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7196; + this.match(PostgreSQLParser.CREATE); + this.state = 7197; + this.match(PostgreSQLParser.DATABASE); + this.state = 7198; + this.name(); + this.state = 7199; + this.opt_with(); + this.state = 7200; + this.createdb_opt_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Createdb_opt_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createdb_opt_list; + return this; +} + +Createdb_opt_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Createdb_opt_listContext.prototype.constructor = Createdb_opt_listContext; + +Createdb_opt_listContext.prototype.createdb_opt_items = function() { + return this.getTypedRuleContext(Createdb_opt_itemsContext,0); +}; + +Createdb_opt_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatedb_opt_list(this); + } +}; + +Createdb_opt_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatedb_opt_list(this); + } +}; + +Createdb_opt_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatedb_opt_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Createdb_opt_listContext = Createdb_opt_listContext; + +PostgreSQLParser.prototype.createdb_opt_list = function() { + + var localctx = new Createdb_opt_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 806, PostgreSQLParser.RULE_createdb_opt_list); + try { + this.state = 7204; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,342,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7202; + this.createdb_opt_items(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Createdb_opt_itemsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createdb_opt_items; + return this; +} + +Createdb_opt_itemsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Createdb_opt_itemsContext.prototype.constructor = Createdb_opt_itemsContext; + +Createdb_opt_itemsContext.prototype.createdb_opt_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Createdb_opt_itemContext); + } else { + return this.getTypedRuleContext(Createdb_opt_itemContext,i); + } +}; + +Createdb_opt_itemsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatedb_opt_items(this); + } +}; + +Createdb_opt_itemsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatedb_opt_items(this); + } +}; + +Createdb_opt_itemsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatedb_opt_items(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Createdb_opt_itemsContext = Createdb_opt_itemsContext; + +PostgreSQLParser.prototype.createdb_opt_items = function() { + + var localctx = new Createdb_opt_itemsContext(this, this._ctx, this.state); + this.enterRule(localctx, 808, PostgreSQLParser.RULE_createdb_opt_items); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7207; + this._errHandler.sync(this); + var _alt = 1; + do { + switch (_alt) { + case 1: + this.state = 7206; + this.createdb_opt_item(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 7209; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,343, this._ctx); + } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER ); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Createdb_opt_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createdb_opt_item; + return this; +} + +Createdb_opt_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Createdb_opt_itemContext.prototype.constructor = Createdb_opt_itemContext; + +Createdb_opt_itemContext.prototype.createdb_opt_name = function() { + return this.getTypedRuleContext(Createdb_opt_nameContext,0); +}; + +Createdb_opt_itemContext.prototype.opt_equal = function() { + return this.getTypedRuleContext(Opt_equalContext,0); +}; + +Createdb_opt_itemContext.prototype.signediconst = function() { + return this.getTypedRuleContext(SignediconstContext,0); +}; + +Createdb_opt_itemContext.prototype.opt_boolean_or_string = function() { + return this.getTypedRuleContext(Opt_boolean_or_stringContext,0); +}; + +Createdb_opt_itemContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Createdb_opt_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatedb_opt_item(this); + } +}; + +Createdb_opt_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatedb_opt_item(this); + } +}; + +Createdb_opt_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatedb_opt_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Createdb_opt_itemContext = Createdb_opt_itemContext; + +PostgreSQLParser.prototype.createdb_opt_item = function() { + + var localctx = new Createdb_opt_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 810, PostgreSQLParser.RULE_createdb_opt_item); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7211; + this.createdb_opt_name(); + this.state = 7212; + this.opt_equal(); + this.state = 7216; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,344,this._ctx); + switch(la_) { + case 1: + this.state = 7213; + this.signediconst(); + break; + + case 2: + this.state = 7214; + this.opt_boolean_or_string(); + break; + + case 3: + this.state = 7215; + this.match(PostgreSQLParser.DEFAULT); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Createdb_opt_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createdb_opt_name; + return this; +} + +Createdb_opt_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Createdb_opt_nameContext.prototype.constructor = Createdb_opt_nameContext; + +Createdb_opt_nameContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +Createdb_opt_nameContext.prototype.CONNECTION = function() { + return this.getToken(PostgreSQLParser.CONNECTION, 0); +}; + +Createdb_opt_nameContext.prototype.LIMIT = function() { + return this.getToken(PostgreSQLParser.LIMIT, 0); +}; + +Createdb_opt_nameContext.prototype.ENCODING = function() { + return this.getToken(PostgreSQLParser.ENCODING, 0); +}; + +Createdb_opt_nameContext.prototype.LOCATION = function() { + return this.getToken(PostgreSQLParser.LOCATION, 0); +}; + +Createdb_opt_nameContext.prototype.OWNER = function() { + return this.getToken(PostgreSQLParser.OWNER, 0); +}; + +Createdb_opt_nameContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +Createdb_opt_nameContext.prototype.TEMPLATE = function() { + return this.getToken(PostgreSQLParser.TEMPLATE, 0); +}; + +Createdb_opt_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatedb_opt_name(this); + } +}; + +Createdb_opt_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatedb_opt_name(this); + } +}; + +Createdb_opt_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatedb_opt_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Createdb_opt_nameContext = Createdb_opt_nameContext; + +PostgreSQLParser.prototype.createdb_opt_name = function() { + + var localctx = new Createdb_opt_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 812, PostgreSQLParser.RULE_createdb_opt_name); + try { + this.state = 7226; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RESET: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SET: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 7218; + this.identifier(); + break; + case PostgreSQLParser.CONNECTION: + this.enterOuterAlt(localctx, 2); + this.state = 7219; + this.match(PostgreSQLParser.CONNECTION); + this.state = 7220; + this.match(PostgreSQLParser.LIMIT); + break; + case PostgreSQLParser.ENCODING: + this.enterOuterAlt(localctx, 3); + this.state = 7221; + this.match(PostgreSQLParser.ENCODING); + break; + case PostgreSQLParser.LOCATION: + this.enterOuterAlt(localctx, 4); + this.state = 7222; + this.match(PostgreSQLParser.LOCATION); + break; + case PostgreSQLParser.OWNER: + this.enterOuterAlt(localctx, 5); + this.state = 7223; + this.match(PostgreSQLParser.OWNER); + break; + case PostgreSQLParser.TABLESPACE: + this.enterOuterAlt(localctx, 6); + this.state = 7224; + this.match(PostgreSQLParser.TABLESPACE); + break; + case PostgreSQLParser.TEMPLATE: + this.enterOuterAlt(localctx, 7); + this.state = 7225; + this.match(PostgreSQLParser.TEMPLATE); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_equalContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_equal; + return this; +} + +Opt_equalContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_equalContext.prototype.constructor = Opt_equalContext; + +Opt_equalContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +Opt_equalContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_equal(this); + } +}; + +Opt_equalContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_equal(this); + } +}; + +Opt_equalContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_equal(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_equalContext = Opt_equalContext; + +PostgreSQLParser.prototype.opt_equal = function() { + + var localctx = new Opt_equalContext(this, this._ctx, this.state); + this.enterRule(localctx, 814, PostgreSQLParser.RULE_opt_equal); + try { + this.state = 7230; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.EQUAL: + this.enterOuterAlt(localctx, 1); + this.state = 7228; + this.match(PostgreSQLParser.EQUAL); + break; + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.ON: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterdatabasestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterdatabasestmt; + return this; +} + +AlterdatabasestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterdatabasestmtContext.prototype.constructor = AlterdatabasestmtContext; + +AlterdatabasestmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterdatabasestmtContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +AlterdatabasestmtContext.prototype.name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(NameContext); + } else { + return this.getTypedRuleContext(NameContext,i); + } +}; + +AlterdatabasestmtContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +AlterdatabasestmtContext.prototype.createdb_opt_list = function() { + return this.getTypedRuleContext(Createdb_opt_listContext,0); +}; + +AlterdatabasestmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AlterdatabasestmtContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +AlterdatabasestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterdatabasestmt(this); + } +}; + +AlterdatabasestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterdatabasestmt(this); + } +}; + +AlterdatabasestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterdatabasestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterdatabasestmtContext = AlterdatabasestmtContext; + +PostgreSQLParser.prototype.alterdatabasestmt = function() { + + var localctx = new AlterdatabasestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 816, PostgreSQLParser.RULE_alterdatabasestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7232; + this.match(PostgreSQLParser.ALTER); + this.state = 7233; + this.match(PostgreSQLParser.DATABASE); + this.state = 7234; + this.name(); + this.state = 7241; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,347,this._ctx); + switch(la_) { + case 1: + this.state = 7235; + this.match(PostgreSQLParser.WITH); + this.state = 7236; + this.createdb_opt_list(); + break; + + case 2: + this.state = 7237; + this.createdb_opt_list(); + break; + + case 3: + this.state = 7238; + this.match(PostgreSQLParser.SET); + this.state = 7239; + this.match(PostgreSQLParser.TABLESPACE); + this.state = 7240; + this.name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterdatabasesetstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterdatabasesetstmt; + return this; +} + +AlterdatabasesetstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterdatabasesetstmtContext.prototype.constructor = AlterdatabasesetstmtContext; + +AlterdatabasesetstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterdatabasesetstmtContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +AlterdatabasesetstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AlterdatabasesetstmtContext.prototype.setresetclause = function() { + return this.getTypedRuleContext(SetresetclauseContext,0); +}; + +AlterdatabasesetstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterdatabasesetstmt(this); + } +}; + +AlterdatabasesetstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterdatabasesetstmt(this); + } +}; + +AlterdatabasesetstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterdatabasesetstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterdatabasesetstmtContext = AlterdatabasesetstmtContext; + +PostgreSQLParser.prototype.alterdatabasesetstmt = function() { + + var localctx = new AlterdatabasesetstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 818, PostgreSQLParser.RULE_alterdatabasesetstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7243; + this.match(PostgreSQLParser.ALTER); + this.state = 7244; + this.match(PostgreSQLParser.DATABASE); + this.state = 7245; + this.name(); + this.state = 7246; + this.setresetclause(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DropdbstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_dropdbstmt; + return this; +} + +DropdbstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DropdbstmtContext.prototype.constructor = DropdbstmtContext; + +DropdbstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +DropdbstmtContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +DropdbstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +DropdbstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +DropdbstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +DropdbstmtContext.prototype.opt_with = function() { + return this.getTypedRuleContext(Opt_withContext,0); +}; + +DropdbstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +DropdbstmtContext.prototype.drop_option_list = function() { + return this.getTypedRuleContext(Drop_option_listContext,0); +}; + +DropdbstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +DropdbstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDropdbstmt(this); + } +}; + +DropdbstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDropdbstmt(this); + } +}; + +DropdbstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDropdbstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DropdbstmtContext = DropdbstmtContext; + +PostgreSQLParser.prototype.dropdbstmt = function() { + + var localctx = new DropdbstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 820, PostgreSQLParser.RULE_dropdbstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7248; + this.match(PostgreSQLParser.DROP); + this.state = 7249; + this.match(PostgreSQLParser.DATABASE); + this.state = 7252; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,348,this._ctx); + if(la_===1) { + this.state = 7250; + this.match(PostgreSQLParser.IF_P); + this.state = 7251; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 7254; + this.name(); + this.state = 7260; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,349,this._ctx); + if(la_===1) { + this.state = 7255; + this.opt_with(); + this.state = 7256; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7257; + this.drop_option_list(); + this.state = 7258; + this.match(PostgreSQLParser.CLOSE_PAREN); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Drop_option_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_drop_option_list; + return this; +} + +Drop_option_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Drop_option_listContext.prototype.constructor = Drop_option_listContext; + +Drop_option_listContext.prototype.drop_option = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Drop_optionContext); + } else { + return this.getTypedRuleContext(Drop_optionContext,i); + } +}; + +Drop_option_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Drop_option_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDrop_option_list(this); + } +}; + +Drop_option_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDrop_option_list(this); + } +}; + +Drop_option_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDrop_option_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Drop_option_listContext = Drop_option_listContext; + +PostgreSQLParser.prototype.drop_option_list = function() { + + var localctx = new Drop_option_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 822, PostgreSQLParser.RULE_drop_option_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7262; + this.drop_option(); + this.state = 7267; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 7263; + this.match(PostgreSQLParser.COMMA); + this.state = 7264; + this.drop_option(); + this.state = 7269; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Drop_optionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_drop_option; + return this; +} + +Drop_optionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Drop_optionContext.prototype.constructor = Drop_optionContext; + +Drop_optionContext.prototype.FORCE = function() { + return this.getToken(PostgreSQLParser.FORCE, 0); +}; + +Drop_optionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDrop_option(this); + } +}; + +Drop_optionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDrop_option(this); + } +}; + +Drop_optionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDrop_option(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Drop_optionContext = Drop_optionContext; + +PostgreSQLParser.prototype.drop_option = function() { + + var localctx = new Drop_optionContext(this, this._ctx, this.state); + this.enterRule(localctx, 824, PostgreSQLParser.RULE_drop_option); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7270; + this.match(PostgreSQLParser.FORCE); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltercollationstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altercollationstmt; + return this; +} + +AltercollationstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltercollationstmtContext.prototype.constructor = AltercollationstmtContext; + +AltercollationstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AltercollationstmtContext.prototype.COLLATION = function() { + return this.getToken(PostgreSQLParser.COLLATION, 0); +}; + +AltercollationstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AltercollationstmtContext.prototype.REFRESH = function() { + return this.getToken(PostgreSQLParser.REFRESH, 0); +}; + +AltercollationstmtContext.prototype.VERSION_P = function() { + return this.getToken(PostgreSQLParser.VERSION_P, 0); +}; + +AltercollationstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltercollationstmt(this); + } +}; + +AltercollationstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltercollationstmt(this); + } +}; + +AltercollationstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltercollationstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltercollationstmtContext = AltercollationstmtContext; + +PostgreSQLParser.prototype.altercollationstmt = function() { + + var localctx = new AltercollationstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 826, PostgreSQLParser.RULE_altercollationstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7272; + this.match(PostgreSQLParser.ALTER); + this.state = 7273; + this.match(PostgreSQLParser.COLLATION); + this.state = 7274; + this.any_name(); + this.state = 7275; + this.match(PostgreSQLParser.REFRESH); + this.state = 7276; + this.match(PostgreSQLParser.VERSION_P); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltersystemstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altersystemstmt; + return this; +} + +AltersystemstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltersystemstmtContext.prototype.constructor = AltersystemstmtContext; + +AltersystemstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AltersystemstmtContext.prototype.SYSTEM_P = function() { + return this.getToken(PostgreSQLParser.SYSTEM_P, 0); +}; + +AltersystemstmtContext.prototype.generic_set = function() { + return this.getTypedRuleContext(Generic_setContext,0); +}; + +AltersystemstmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AltersystemstmtContext.prototype.RESET = function() { + return this.getToken(PostgreSQLParser.RESET, 0); +}; + +AltersystemstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltersystemstmt(this); + } +}; + +AltersystemstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltersystemstmt(this); + } +}; + +AltersystemstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltersystemstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltersystemstmtContext = AltersystemstmtContext; + +PostgreSQLParser.prototype.altersystemstmt = function() { + + var localctx = new AltersystemstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 828, PostgreSQLParser.RULE_altersystemstmt); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7278; + this.match(PostgreSQLParser.ALTER); + this.state = 7279; + this.match(PostgreSQLParser.SYSTEM_P); + this.state = 7280; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.RESET || _la===PostgreSQLParser.SET)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 7281; + this.generic_set(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreatedomainstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createdomainstmt; + return this; +} + +CreatedomainstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreatedomainstmtContext.prototype.constructor = CreatedomainstmtContext; + +CreatedomainstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreatedomainstmtContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +CreatedomainstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +CreatedomainstmtContext.prototype.opt_as = function() { + return this.getTypedRuleContext(Opt_asContext,0); +}; + +CreatedomainstmtContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +CreatedomainstmtContext.prototype.colquallist = function() { + return this.getTypedRuleContext(ColquallistContext,0); +}; + +CreatedomainstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreatedomainstmt(this); + } +}; + +CreatedomainstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreatedomainstmt(this); + } +}; + +CreatedomainstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreatedomainstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreatedomainstmtContext = CreatedomainstmtContext; + +PostgreSQLParser.prototype.createdomainstmt = function() { + + var localctx = new CreatedomainstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 830, PostgreSQLParser.RULE_createdomainstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7283; + this.match(PostgreSQLParser.CREATE); + this.state = 7284; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 7285; + this.any_name(); + this.state = 7286; + this.opt_as(); + this.state = 7287; + this.typename(); + this.state = 7288; + this.colquallist(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AlterdomainstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alterdomainstmt; + return this; +} + +AlterdomainstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AlterdomainstmtContext.prototype.constructor = AlterdomainstmtContext; + +AlterdomainstmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AlterdomainstmtContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +AlterdomainstmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AlterdomainstmtContext.prototype.alter_column_default = function() { + return this.getTypedRuleContext(Alter_column_defaultContext,0); +}; + +AlterdomainstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +AlterdomainstmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +AlterdomainstmtContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +AlterdomainstmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +AlterdomainstmtContext.prototype.ADD_P = function() { + return this.getToken(PostgreSQLParser.ADD_P, 0); +}; + +AlterdomainstmtContext.prototype.tableconstraint = function() { + return this.getTypedRuleContext(TableconstraintContext,0); +}; + +AlterdomainstmtContext.prototype.CONSTRAINT = function() { + return this.getToken(PostgreSQLParser.CONSTRAINT, 0); +}; + +AlterdomainstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +AlterdomainstmtContext.prototype.opt_drop_behavior = function() { + return this.getTypedRuleContext(Opt_drop_behaviorContext,0); +}; + +AlterdomainstmtContext.prototype.VALIDATE = function() { + return this.getToken(PostgreSQLParser.VALIDATE, 0); +}; + +AlterdomainstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +AlterdomainstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +AlterdomainstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlterdomainstmt(this); + } +}; + +AlterdomainstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlterdomainstmt(this); + } +}; + +AlterdomainstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlterdomainstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AlterdomainstmtContext = AlterdomainstmtContext; + +PostgreSQLParser.prototype.alterdomainstmt = function() { + + var localctx = new AlterdomainstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 832, PostgreSQLParser.RULE_alterdomainstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7290; + this.match(PostgreSQLParser.ALTER); + this.state = 7291; + this.match(PostgreSQLParser.DOMAIN_P); + this.state = 7292; + this.any_name(); + this.state = 7314; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,352,this._ctx); + switch(la_) { + case 1: + this.state = 7293; + this.alter_column_default(); + break; + + case 2: + this.state = 7294; + this.match(PostgreSQLParser.DROP); + this.state = 7295; + this.match(PostgreSQLParser.NOT); + this.state = 7296; + this.match(PostgreSQLParser.NULL_P); + break; + + case 3: + this.state = 7297; + this.match(PostgreSQLParser.SET); + this.state = 7298; + this.match(PostgreSQLParser.NOT); + this.state = 7299; + this.match(PostgreSQLParser.NULL_P); + break; + + case 4: + this.state = 7300; + this.match(PostgreSQLParser.ADD_P); + this.state = 7301; + this.tableconstraint(); + break; + + case 5: + this.state = 7302; + this.match(PostgreSQLParser.DROP); + this.state = 7303; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 7306; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,351,this._ctx); + if(la_===1) { + this.state = 7304; + this.match(PostgreSQLParser.IF_P); + this.state = 7305; + this.match(PostgreSQLParser.EXISTS); + + } + this.state = 7308; + this.name(); + this.state = 7309; + this.opt_drop_behavior(); + break; + + case 6: + this.state = 7311; + this.match(PostgreSQLParser.VALIDATE); + this.state = 7312; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 7313; + this.name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_asContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_as; + return this; +} + +Opt_asContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_asContext.prototype.constructor = Opt_asContext; + +Opt_asContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Opt_asContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_as(this); + } +}; + +Opt_asContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_as(this); + } +}; + +Opt_asContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_as(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_asContext = Opt_asContext; + +PostgreSQLParser.prototype.opt_as = function() { + + var localctx = new Opt_asContext(this, this._ctx, this.state); + this.enterRule(localctx, 834, PostgreSQLParser.RULE_opt_as); + try { + this.state = 7318; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AS: + this.enterOuterAlt(localctx, 1); + this.state = 7316; + this.match(PostgreSQLParser.AS); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltertsdictionarystmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altertsdictionarystmt; + return this; +} + +AltertsdictionarystmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltertsdictionarystmtContext.prototype.constructor = AltertsdictionarystmtContext; + +AltertsdictionarystmtContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +AltertsdictionarystmtContext.prototype.TEXT_P = function() { + return this.getToken(PostgreSQLParser.TEXT_P, 0); +}; + +AltertsdictionarystmtContext.prototype.SEARCH = function() { + return this.getToken(PostgreSQLParser.SEARCH, 0); +}; + +AltertsdictionarystmtContext.prototype.DICTIONARY = function() { + return this.getToken(PostgreSQLParser.DICTIONARY, 0); +}; + +AltertsdictionarystmtContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +AltertsdictionarystmtContext.prototype.definition = function() { + return this.getTypedRuleContext(DefinitionContext,0); +}; + +AltertsdictionarystmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltertsdictionarystmt(this); + } +}; + +AltertsdictionarystmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltertsdictionarystmt(this); + } +}; + +AltertsdictionarystmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltertsdictionarystmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltertsdictionarystmtContext = AltertsdictionarystmtContext; + +PostgreSQLParser.prototype.altertsdictionarystmt = function() { + + var localctx = new AltertsdictionarystmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 836, PostgreSQLParser.RULE_altertsdictionarystmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7320; + this.match(PostgreSQLParser.ALTER); + this.state = 7321; + this.match(PostgreSQLParser.TEXT_P); + this.state = 7322; + this.match(PostgreSQLParser.SEARCH); + this.state = 7323; + this.match(PostgreSQLParser.DICTIONARY); + this.state = 7324; + this.any_name(); + this.state = 7325; + this.definition(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AltertsconfigurationstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_altertsconfigurationstmt; + return this; +} + +AltertsconfigurationstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AltertsconfigurationstmtContext.prototype.constructor = AltertsconfigurationstmtContext; + +AltertsconfigurationstmtContext.prototype.ALTER = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.ALTER); + } else { + return this.getToken(PostgreSQLParser.ALTER, i); + } +}; + + +AltertsconfigurationstmtContext.prototype.TEXT_P = function() { + return this.getToken(PostgreSQLParser.TEXT_P, 0); +}; + +AltertsconfigurationstmtContext.prototype.SEARCH = function() { + return this.getToken(PostgreSQLParser.SEARCH, 0); +}; + +AltertsconfigurationstmtContext.prototype.CONFIGURATION = function() { + return this.getToken(PostgreSQLParser.CONFIGURATION, 0); +}; + +AltertsconfigurationstmtContext.prototype.any_name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Any_nameContext); + } else { + return this.getTypedRuleContext(Any_nameContext,i); + } +}; + +AltertsconfigurationstmtContext.prototype.ADD_P = function() { + return this.getToken(PostgreSQLParser.ADD_P, 0); +}; + +AltertsconfigurationstmtContext.prototype.MAPPING = function() { + return this.getToken(PostgreSQLParser.MAPPING, 0); +}; + +AltertsconfigurationstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +AltertsconfigurationstmtContext.prototype.name_list = function() { + return this.getTypedRuleContext(Name_listContext,0); +}; + +AltertsconfigurationstmtContext.prototype.any_with = function() { + return this.getTypedRuleContext(Any_withContext,0); +}; + +AltertsconfigurationstmtContext.prototype.any_name_list = function() { + return this.getTypedRuleContext(Any_name_listContext,0); +}; + +AltertsconfigurationstmtContext.prototype.REPLACE = function() { + return this.getToken(PostgreSQLParser.REPLACE, 0); +}; + +AltertsconfigurationstmtContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +AltertsconfigurationstmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +AltertsconfigurationstmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +AltertsconfigurationstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAltertsconfigurationstmt(this); + } +}; + +AltertsconfigurationstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAltertsconfigurationstmt(this); + } +}; + +AltertsconfigurationstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAltertsconfigurationstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AltertsconfigurationstmtContext = AltertsconfigurationstmtContext; + +PostgreSQLParser.prototype.altertsconfigurationstmt = function() { + + var localctx = new AltertsconfigurationstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 838, PostgreSQLParser.RULE_altertsconfigurationstmt); + try { + this.state = 7399; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,354,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7327; + this.match(PostgreSQLParser.ALTER); + this.state = 7328; + this.match(PostgreSQLParser.TEXT_P); + this.state = 7329; + this.match(PostgreSQLParser.SEARCH); + this.state = 7330; + this.match(PostgreSQLParser.CONFIGURATION); + this.state = 7331; + this.any_name(); + this.state = 7332; + this.match(PostgreSQLParser.ADD_P); + this.state = 7333; + this.match(PostgreSQLParser.MAPPING); + this.state = 7334; + this.match(PostgreSQLParser.FOR); + this.state = 7335; + this.name_list(); + this.state = 7336; + this.any_with(); + this.state = 7337; + this.any_name_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7339; + this.match(PostgreSQLParser.ALTER); + this.state = 7340; + this.match(PostgreSQLParser.TEXT_P); + this.state = 7341; + this.match(PostgreSQLParser.SEARCH); + this.state = 7342; + this.match(PostgreSQLParser.CONFIGURATION); + this.state = 7343; + this.any_name(); + this.state = 7344; + this.match(PostgreSQLParser.ALTER); + this.state = 7345; + this.match(PostgreSQLParser.MAPPING); + this.state = 7346; + this.match(PostgreSQLParser.FOR); + this.state = 7347; + this.name_list(); + this.state = 7348; + this.any_with(); + this.state = 7349; + this.any_name_list(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7351; + this.match(PostgreSQLParser.ALTER); + this.state = 7352; + this.match(PostgreSQLParser.TEXT_P); + this.state = 7353; + this.match(PostgreSQLParser.SEARCH); + this.state = 7354; + this.match(PostgreSQLParser.CONFIGURATION); + this.state = 7355; + this.any_name(); + this.state = 7356; + this.match(PostgreSQLParser.ALTER); + this.state = 7357; + this.match(PostgreSQLParser.MAPPING); + this.state = 7358; + this.match(PostgreSQLParser.REPLACE); + this.state = 7359; + this.any_name(); + this.state = 7360; + this.any_with(); + this.state = 7361; + this.any_name(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 7363; + this.match(PostgreSQLParser.ALTER); + this.state = 7364; + this.match(PostgreSQLParser.TEXT_P); + this.state = 7365; + this.match(PostgreSQLParser.SEARCH); + this.state = 7366; + this.match(PostgreSQLParser.CONFIGURATION); + this.state = 7367; + this.any_name(); + this.state = 7368; + this.match(PostgreSQLParser.ALTER); + this.state = 7369; + this.match(PostgreSQLParser.MAPPING); + this.state = 7370; + this.match(PostgreSQLParser.FOR); + this.state = 7371; + this.name_list(); + this.state = 7372; + this.match(PostgreSQLParser.REPLACE); + this.state = 7373; + this.any_name(); + this.state = 7374; + this.any_with(); + this.state = 7375; + this.any_name(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 7377; + this.match(PostgreSQLParser.ALTER); + this.state = 7378; + this.match(PostgreSQLParser.TEXT_P); + this.state = 7379; + this.match(PostgreSQLParser.SEARCH); + this.state = 7380; + this.match(PostgreSQLParser.CONFIGURATION); + this.state = 7381; + this.any_name(); + this.state = 7382; + this.match(PostgreSQLParser.DROP); + this.state = 7383; + this.match(PostgreSQLParser.MAPPING); + this.state = 7384; + this.match(PostgreSQLParser.FOR); + this.state = 7385; + this.name_list(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 7387; + this.match(PostgreSQLParser.ALTER); + this.state = 7388; + this.match(PostgreSQLParser.TEXT_P); + this.state = 7389; + this.match(PostgreSQLParser.SEARCH); + this.state = 7390; + this.match(PostgreSQLParser.CONFIGURATION); + this.state = 7391; + this.any_name(); + this.state = 7392; + this.match(PostgreSQLParser.DROP); + this.state = 7393; + this.match(PostgreSQLParser.MAPPING); + this.state = 7394; + this.match(PostgreSQLParser.IF_P); + this.state = 7395; + this.match(PostgreSQLParser.EXISTS); + this.state = 7396; + this.match(PostgreSQLParser.FOR); + this.state = 7397; + this.name_list(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Any_withContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_any_with; + return this; +} + +Any_withContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Any_withContext.prototype.constructor = Any_withContext; + +Any_withContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Any_withContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAny_with(this); + } +}; + +Any_withContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAny_with(this); + } +}; + +Any_withContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAny_with(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Any_withContext = Any_withContext; + +PostgreSQLParser.prototype.any_with = function() { + + var localctx = new Any_withContext(this, this._ctx, this.state); + this.enterRule(localctx, 840, PostgreSQLParser.RULE_any_with); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7401; + this.match(PostgreSQLParser.WITH); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CreateconversionstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_createconversionstmt; + return this; +} + +CreateconversionstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CreateconversionstmtContext.prototype.constructor = CreateconversionstmtContext; + +CreateconversionstmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +CreateconversionstmtContext.prototype.opt_default = function() { + return this.getTypedRuleContext(Opt_defaultContext,0); +}; + +CreateconversionstmtContext.prototype.CONVERSION_P = function() { + return this.getToken(PostgreSQLParser.CONVERSION_P, 0); +}; + +CreateconversionstmtContext.prototype.any_name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Any_nameContext); + } else { + return this.getTypedRuleContext(Any_nameContext,i); + } +}; + +CreateconversionstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +CreateconversionstmtContext.prototype.sconst = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(SconstContext); + } else { + return this.getTypedRuleContext(SconstContext,i); + } +}; + +CreateconversionstmtContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +CreateconversionstmtContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +CreateconversionstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCreateconversionstmt(this); + } +}; + +CreateconversionstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCreateconversionstmt(this); + } +}; + +CreateconversionstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCreateconversionstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CreateconversionstmtContext = CreateconversionstmtContext; + +PostgreSQLParser.prototype.createconversionstmt = function() { + + var localctx = new CreateconversionstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 842, PostgreSQLParser.RULE_createconversionstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7403; + this.match(PostgreSQLParser.CREATE); + this.state = 7404; + this.opt_default(); + this.state = 7405; + this.match(PostgreSQLParser.CONVERSION_P); + this.state = 7406; + this.any_name(); + this.state = 7407; + this.match(PostgreSQLParser.FOR); + this.state = 7408; + this.sconst(); + this.state = 7409; + this.match(PostgreSQLParser.TO); + this.state = 7410; + this.sconst(); + this.state = 7411; + this.match(PostgreSQLParser.FROM); + this.state = 7412; + this.any_name(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ClusterstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_clusterstmt; + return this; +} + +ClusterstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ClusterstmtContext.prototype.constructor = ClusterstmtContext; + +ClusterstmtContext.prototype.CLUSTER = function() { + return this.getToken(PostgreSQLParser.CLUSTER, 0); +}; + +ClusterstmtContext.prototype.opt_verbose = function() { + return this.getTypedRuleContext(Opt_verboseContext,0); +}; + +ClusterstmtContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +ClusterstmtContext.prototype.cluster_index_specification = function() { + return this.getTypedRuleContext(Cluster_index_specificationContext,0); +}; + +ClusterstmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +ClusterstmtContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +ClusterstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterClusterstmt(this); + } +}; + +ClusterstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitClusterstmt(this); + } +}; + +ClusterstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitClusterstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ClusterstmtContext = ClusterstmtContext; + +PostgreSQLParser.prototype.clusterstmt = function() { + + var localctx = new ClusterstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 844, PostgreSQLParser.RULE_clusterstmt); + try { + this.state = 7427; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,355,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7414; + this.match(PostgreSQLParser.CLUSTER); + this.state = 7415; + this.opt_verbose(); + this.state = 7416; + this.qualified_name(); + this.state = 7417; + this.cluster_index_specification(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7419; + this.match(PostgreSQLParser.CLUSTER); + this.state = 7420; + this.opt_verbose(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7421; + this.match(PostgreSQLParser.CLUSTER); + this.state = 7422; + this.opt_verbose(); + this.state = 7423; + this.name(); + this.state = 7424; + this.match(PostgreSQLParser.ON); + this.state = 7425; + this.qualified_name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Cluster_index_specificationContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_cluster_index_specification; + return this; +} + +Cluster_index_specificationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Cluster_index_specificationContext.prototype.constructor = Cluster_index_specificationContext; + +Cluster_index_specificationContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Cluster_index_specificationContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Cluster_index_specificationContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCluster_index_specification(this); + } +}; + +Cluster_index_specificationContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCluster_index_specification(this); + } +}; + +Cluster_index_specificationContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCluster_index_specification(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Cluster_index_specificationContext = Cluster_index_specificationContext; + +PostgreSQLParser.prototype.cluster_index_specification = function() { + + var localctx = new Cluster_index_specificationContext(this, this._ctx, this.state); + this.enterRule(localctx, 846, PostgreSQLParser.RULE_cluster_index_specification); + try { + this.state = 7432; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + this.state = 7429; + this.match(PostgreSQLParser.USING); + this.state = 7430; + this.name(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function VacuumstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_vacuumstmt; + return this; +} + +VacuumstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +VacuumstmtContext.prototype.constructor = VacuumstmtContext; + +VacuumstmtContext.prototype.VACUUM = function() { + return this.getToken(PostgreSQLParser.VACUUM, 0); +}; + +VacuumstmtContext.prototype.opt_full = function() { + return this.getTypedRuleContext(Opt_fullContext,0); +}; + +VacuumstmtContext.prototype.opt_freeze = function() { + return this.getTypedRuleContext(Opt_freezeContext,0); +}; + +VacuumstmtContext.prototype.opt_verbose = function() { + return this.getTypedRuleContext(Opt_verboseContext,0); +}; + +VacuumstmtContext.prototype.opt_analyze = function() { + return this.getTypedRuleContext(Opt_analyzeContext,0); +}; + +VacuumstmtContext.prototype.opt_vacuum_relation_list = function() { + return this.getTypedRuleContext(Opt_vacuum_relation_listContext,0); +}; + +VacuumstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +VacuumstmtContext.prototype.vac_analyze_option_list = function() { + return this.getTypedRuleContext(Vac_analyze_option_listContext,0); +}; + +VacuumstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +VacuumstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVacuumstmt(this); + } +}; + +VacuumstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVacuumstmt(this); + } +}; + +VacuumstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVacuumstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.VacuumstmtContext = VacuumstmtContext; + +PostgreSQLParser.prototype.vacuumstmt = function() { + + var localctx = new VacuumstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 848, PostgreSQLParser.RULE_vacuumstmt); + try { + this.state = 7447; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,357,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7434; + this.match(PostgreSQLParser.VACUUM); + this.state = 7435; + this.opt_full(); + this.state = 7436; + this.opt_freeze(); + this.state = 7437; + this.opt_verbose(); + this.state = 7438; + this.opt_analyze(); + this.state = 7439; + this.opt_vacuum_relation_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7441; + this.match(PostgreSQLParser.VACUUM); + this.state = 7442; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7443; + this.vac_analyze_option_list(); + this.state = 7444; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 7445; + this.opt_vacuum_relation_list(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AnalyzestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_analyzestmt; + return this; +} + +AnalyzestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AnalyzestmtContext.prototype.constructor = AnalyzestmtContext; + +AnalyzestmtContext.prototype.analyze_keyword = function() { + return this.getTypedRuleContext(Analyze_keywordContext,0); +}; + +AnalyzestmtContext.prototype.opt_verbose = function() { + return this.getTypedRuleContext(Opt_verboseContext,0); +}; + +AnalyzestmtContext.prototype.opt_vacuum_relation_list = function() { + return this.getTypedRuleContext(Opt_vacuum_relation_listContext,0); +}; + +AnalyzestmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +AnalyzestmtContext.prototype.vac_analyze_option_list = function() { + return this.getTypedRuleContext(Vac_analyze_option_listContext,0); +}; + +AnalyzestmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +AnalyzestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAnalyzestmt(this); + } +}; + +AnalyzestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAnalyzestmt(this); + } +}; + +AnalyzestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAnalyzestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AnalyzestmtContext = AnalyzestmtContext; + +PostgreSQLParser.prototype.analyzestmt = function() { + + var localctx = new AnalyzestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 850, PostgreSQLParser.RULE_analyzestmt); + try { + this.state = 7459; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,358,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7449; + this.analyze_keyword(); + this.state = 7450; + this.opt_verbose(); + this.state = 7451; + this.opt_vacuum_relation_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7453; + this.analyze_keyword(); + this.state = 7454; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7455; + this.vac_analyze_option_list(); + this.state = 7456; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 7457; + this.opt_vacuum_relation_list(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Vac_analyze_option_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_vac_analyze_option_list; + return this; +} + +Vac_analyze_option_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Vac_analyze_option_listContext.prototype.constructor = Vac_analyze_option_listContext; + +Vac_analyze_option_listContext.prototype.vac_analyze_option_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Vac_analyze_option_elemContext); + } else { + return this.getTypedRuleContext(Vac_analyze_option_elemContext,i); + } +}; + +Vac_analyze_option_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Vac_analyze_option_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVac_analyze_option_list(this); + } +}; + +Vac_analyze_option_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVac_analyze_option_list(this); + } +}; + +Vac_analyze_option_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVac_analyze_option_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Vac_analyze_option_listContext = Vac_analyze_option_listContext; + +PostgreSQLParser.prototype.vac_analyze_option_list = function() { + + var localctx = new Vac_analyze_option_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 852, PostgreSQLParser.RULE_vac_analyze_option_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7461; + this.vac_analyze_option_elem(); + this.state = 7466; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 7462; + this.match(PostgreSQLParser.COMMA); + this.state = 7463; + this.vac_analyze_option_elem(); + this.state = 7468; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Analyze_keywordContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_analyze_keyword; + return this; +} + +Analyze_keywordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Analyze_keywordContext.prototype.constructor = Analyze_keywordContext; + +Analyze_keywordContext.prototype.ANALYZE = function() { + return this.getToken(PostgreSQLParser.ANALYZE, 0); +}; + +Analyze_keywordContext.prototype.ANALYSE = function() { + return this.getToken(PostgreSQLParser.ANALYSE, 0); +}; + +Analyze_keywordContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAnalyze_keyword(this); + } +}; + +Analyze_keywordContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAnalyze_keyword(this); + } +}; + +Analyze_keywordContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAnalyze_keyword(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Analyze_keywordContext = Analyze_keywordContext; + +PostgreSQLParser.prototype.analyze_keyword = function() { + + var localctx = new Analyze_keywordContext(this, this._ctx, this.state); + this.enterRule(localctx, 854, PostgreSQLParser.RULE_analyze_keyword); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7469; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.ANALYSE || _la===PostgreSQLParser.ANALYZE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Vac_analyze_option_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_vac_analyze_option_elem; + return this; +} + +Vac_analyze_option_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Vac_analyze_option_elemContext.prototype.constructor = Vac_analyze_option_elemContext; + +Vac_analyze_option_elemContext.prototype.vac_analyze_option_name = function() { + return this.getTypedRuleContext(Vac_analyze_option_nameContext,0); +}; + +Vac_analyze_option_elemContext.prototype.vac_analyze_option_arg = function() { + return this.getTypedRuleContext(Vac_analyze_option_argContext,0); +}; + +Vac_analyze_option_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVac_analyze_option_elem(this); + } +}; + +Vac_analyze_option_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVac_analyze_option_elem(this); + } +}; + +Vac_analyze_option_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVac_analyze_option_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Vac_analyze_option_elemContext = Vac_analyze_option_elemContext; + +PostgreSQLParser.prototype.vac_analyze_option_elem = function() { + + var localctx = new Vac_analyze_option_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 856, PostgreSQLParser.RULE_vac_analyze_option_elem); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7471; + this.vac_analyze_option_name(); + this.state = 7472; + this.vac_analyze_option_arg(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Vac_analyze_option_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_vac_analyze_option_name; + return this; +} + +Vac_analyze_option_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Vac_analyze_option_nameContext.prototype.constructor = Vac_analyze_option_nameContext; + +Vac_analyze_option_nameContext.prototype.nonreservedword = function() { + return this.getTypedRuleContext(NonreservedwordContext,0); +}; + +Vac_analyze_option_nameContext.prototype.analyze_keyword = function() { + return this.getTypedRuleContext(Analyze_keywordContext,0); +}; + +Vac_analyze_option_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVac_analyze_option_name(this); + } +}; + +Vac_analyze_option_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVac_analyze_option_name(this); + } +}; + +Vac_analyze_option_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVac_analyze_option_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Vac_analyze_option_nameContext = Vac_analyze_option_nameContext; + +PostgreSQLParser.prototype.vac_analyze_option_name = function() { + + var localctx = new Vac_analyze_option_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 858, PostgreSQLParser.RULE_vac_analyze_option_name); + try { + this.state = 7476; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 7474; + this.nonreservedword(); + break; + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + this.enterOuterAlt(localctx, 2); + this.state = 7475; + this.analyze_keyword(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Vac_analyze_option_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_vac_analyze_option_arg; + return this; +} + +Vac_analyze_option_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Vac_analyze_option_argContext.prototype.constructor = Vac_analyze_option_argContext; + +Vac_analyze_option_argContext.prototype.opt_boolean_or_string = function() { + return this.getTypedRuleContext(Opt_boolean_or_stringContext,0); +}; + +Vac_analyze_option_argContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +Vac_analyze_option_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVac_analyze_option_arg(this); + } +}; + +Vac_analyze_option_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVac_analyze_option_arg(this); + } +}; + +Vac_analyze_option_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVac_analyze_option_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Vac_analyze_option_argContext = Vac_analyze_option_argContext; + +PostgreSQLParser.prototype.vac_analyze_option_arg = function() { + + var localctx = new Vac_analyze_option_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 860, PostgreSQLParser.RULE_vac_analyze_option_arg); + try { + this.state = 7481; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.ON: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 7478; + this.opt_boolean_or_string(); + break; + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + this.enterOuterAlt(localctx, 2); + this.state = 7479; + this.numericonly(); + break; + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_analyzeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_analyze; + return this; +} + +Opt_analyzeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_analyzeContext.prototype.constructor = Opt_analyzeContext; + +Opt_analyzeContext.prototype.analyze_keyword = function() { + return this.getTypedRuleContext(Analyze_keywordContext,0); +}; + +Opt_analyzeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_analyze(this); + } +}; + +Opt_analyzeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_analyze(this); + } +}; + +Opt_analyzeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_analyze(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_analyzeContext = Opt_analyzeContext; + +PostgreSQLParser.prototype.opt_analyze = function() { + + var localctx = new Opt_analyzeContext(this, this._ctx, this.state); + this.enterRule(localctx, 862, PostgreSQLParser.RULE_opt_analyze); + try { + this.state = 7485; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,362,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7483; + this.analyze_keyword(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_verboseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_verbose; + return this; +} + +Opt_verboseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_verboseContext.prototype.constructor = Opt_verboseContext; + +Opt_verboseContext.prototype.VERBOSE = function() { + return this.getToken(PostgreSQLParser.VERBOSE, 0); +}; + +Opt_verboseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_verbose(this); + } +}; + +Opt_verboseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_verbose(this); + } +}; + +Opt_verboseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_verbose(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_verboseContext = Opt_verboseContext; + +PostgreSQLParser.prototype.opt_verbose = function() { + + var localctx = new Opt_verboseContext(this, this._ctx, this.state); + this.enterRule(localctx, 864, PostgreSQLParser.RULE_opt_verbose); + try { + this.state = 7489; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.VERBOSE: + this.enterOuterAlt(localctx, 1); + this.state = 7487; + this.match(PostgreSQLParser.VERBOSE); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_fullContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_full; + return this; +} + +Opt_fullContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_fullContext.prototype.constructor = Opt_fullContext; + +Opt_fullContext.prototype.FULL = function() { + return this.getToken(PostgreSQLParser.FULL, 0); +}; + +Opt_fullContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_full(this); + } +}; + +Opt_fullContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_full(this); + } +}; + +Opt_fullContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_full(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_fullContext = Opt_fullContext; + +PostgreSQLParser.prototype.opt_full = function() { + + var localctx = new Opt_fullContext(this, this._ctx, this.state); + this.enterRule(localctx, 866, PostgreSQLParser.RULE_opt_full); + try { + this.state = 7493; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FULL: + this.enterOuterAlt(localctx, 1); + this.state = 7491; + this.match(PostgreSQLParser.FULL); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_freezeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_freeze; + return this; +} + +Opt_freezeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_freezeContext.prototype.constructor = Opt_freezeContext; + +Opt_freezeContext.prototype.FREEZE = function() { + return this.getToken(PostgreSQLParser.FREEZE, 0); +}; + +Opt_freezeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_freeze(this); + } +}; + +Opt_freezeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_freeze(this); + } +}; + +Opt_freezeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_freeze(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_freezeContext = Opt_freezeContext; + +PostgreSQLParser.prototype.opt_freeze = function() { + + var localctx = new Opt_freezeContext(this, this._ctx, this.state); + this.enterRule(localctx, 868, PostgreSQLParser.RULE_opt_freeze); + try { + this.state = 7497; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FREEZE: + this.enterOuterAlt(localctx, 1); + this.state = 7495; + this.match(PostgreSQLParser.FREEZE); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_name_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_name_list; + return this; +} + +Opt_name_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_name_listContext.prototype.constructor = Opt_name_listContext; + +Opt_name_listContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opt_name_listContext.prototype.name_list = function() { + return this.getTypedRuleContext(Name_listContext,0); +}; + +Opt_name_listContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opt_name_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_name_list(this); + } +}; + +Opt_name_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_name_list(this); + } +}; + +Opt_name_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_name_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_name_listContext = Opt_name_listContext; + +PostgreSQLParser.prototype.opt_name_list = function() { + + var localctx = new Opt_name_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 870, PostgreSQLParser.RULE_opt_name_list); + try { + this.state = 7504; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,366,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7499; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7500; + this.name_list(); + this.state = 7501; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Vacuum_relationContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_vacuum_relation; + return this; +} + +Vacuum_relationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Vacuum_relationContext.prototype.constructor = Vacuum_relationContext; + +Vacuum_relationContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +Vacuum_relationContext.prototype.opt_name_list = function() { + return this.getTypedRuleContext(Opt_name_listContext,0); +}; + +Vacuum_relationContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVacuum_relation(this); + } +}; + +Vacuum_relationContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVacuum_relation(this); + } +}; + +Vacuum_relationContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVacuum_relation(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Vacuum_relationContext = Vacuum_relationContext; + +PostgreSQLParser.prototype.vacuum_relation = function() { + + var localctx = new Vacuum_relationContext(this, this._ctx, this.state); + this.enterRule(localctx, 872, PostgreSQLParser.RULE_vacuum_relation); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7506; + this.qualified_name(); + this.state = 7507; + this.opt_name_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Vacuum_relation_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_vacuum_relation_list; + return this; +} + +Vacuum_relation_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Vacuum_relation_listContext.prototype.constructor = Vacuum_relation_listContext; + +Vacuum_relation_listContext.prototype.vacuum_relation = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Vacuum_relationContext); + } else { + return this.getTypedRuleContext(Vacuum_relationContext,i); + } +}; + +Vacuum_relation_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Vacuum_relation_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterVacuum_relation_list(this); + } +}; + +Vacuum_relation_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitVacuum_relation_list(this); + } +}; + +Vacuum_relation_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitVacuum_relation_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Vacuum_relation_listContext = Vacuum_relation_listContext; + +PostgreSQLParser.prototype.vacuum_relation_list = function() { + + var localctx = new Vacuum_relation_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 874, PostgreSQLParser.RULE_vacuum_relation_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7509; + this.vacuum_relation(); + this.state = 7514; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 7510; + this.match(PostgreSQLParser.COMMA); + this.state = 7511; + this.vacuum_relation(); + this.state = 7516; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_vacuum_relation_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_vacuum_relation_list; + return this; +} + +Opt_vacuum_relation_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_vacuum_relation_listContext.prototype.constructor = Opt_vacuum_relation_listContext; + +Opt_vacuum_relation_listContext.prototype.vacuum_relation_list = function() { + return this.getTypedRuleContext(Vacuum_relation_listContext,0); +}; + +Opt_vacuum_relation_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_vacuum_relation_list(this); + } +}; + +Opt_vacuum_relation_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_vacuum_relation_list(this); + } +}; + +Opt_vacuum_relation_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_vacuum_relation_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_vacuum_relation_listContext = Opt_vacuum_relation_listContext; + +PostgreSQLParser.prototype.opt_vacuum_relation_list = function() { + + var localctx = new Opt_vacuum_relation_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 876, PostgreSQLParser.RULE_opt_vacuum_relation_list); + try { + this.state = 7519; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,368,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7517; + this.vacuum_relation_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ExplainstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_explainstmt; + return this; +} + +ExplainstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ExplainstmtContext.prototype.constructor = ExplainstmtContext; + +ExplainstmtContext.prototype.EXPLAIN = function() { + return this.getToken(PostgreSQLParser.EXPLAIN, 0); +}; + +ExplainstmtContext.prototype.explainablestmt = function() { + return this.getTypedRuleContext(ExplainablestmtContext,0); +}; + +ExplainstmtContext.prototype.analyze_keyword = function() { + return this.getTypedRuleContext(Analyze_keywordContext,0); +}; + +ExplainstmtContext.prototype.opt_verbose = function() { + return this.getTypedRuleContext(Opt_verboseContext,0); +}; + +ExplainstmtContext.prototype.VERBOSE = function() { + return this.getToken(PostgreSQLParser.VERBOSE, 0); +}; + +ExplainstmtContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +ExplainstmtContext.prototype.explain_option_list = function() { + return this.getTypedRuleContext(Explain_option_listContext,0); +}; + +ExplainstmtContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +ExplainstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExplainstmt(this); + } +}; + +ExplainstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExplainstmt(this); + } +}; + +ExplainstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExplainstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ExplainstmtContext = ExplainstmtContext; + +PostgreSQLParser.prototype.explainstmt = function() { + + var localctx = new ExplainstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 878, PostgreSQLParser.RULE_explainstmt); + try { + this.state = 7537; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,369,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7521; + this.match(PostgreSQLParser.EXPLAIN); + this.state = 7522; + this.explainablestmt(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7523; + this.match(PostgreSQLParser.EXPLAIN); + this.state = 7524; + this.analyze_keyword(); + this.state = 7525; + this.opt_verbose(); + this.state = 7526; + this.explainablestmt(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7528; + this.match(PostgreSQLParser.EXPLAIN); + this.state = 7529; + this.match(PostgreSQLParser.VERBOSE); + this.state = 7530; + this.explainablestmt(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 7531; + this.match(PostgreSQLParser.EXPLAIN); + this.state = 7532; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7533; + this.explain_option_list(); + this.state = 7534; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 7535; + this.explainablestmt(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ExplainablestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_explainablestmt; + return this; +} + +ExplainablestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ExplainablestmtContext.prototype.constructor = ExplainablestmtContext; + +ExplainablestmtContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +ExplainablestmtContext.prototype.insertstmt = function() { + return this.getTypedRuleContext(InsertstmtContext,0); +}; + +ExplainablestmtContext.prototype.updatestmt = function() { + return this.getTypedRuleContext(UpdatestmtContext,0); +}; + +ExplainablestmtContext.prototype.deletestmt = function() { + return this.getTypedRuleContext(DeletestmtContext,0); +}; + +ExplainablestmtContext.prototype.declarecursorstmt = function() { + return this.getTypedRuleContext(DeclarecursorstmtContext,0); +}; + +ExplainablestmtContext.prototype.createasstmt = function() { + return this.getTypedRuleContext(CreateasstmtContext,0); +}; + +ExplainablestmtContext.prototype.creatematviewstmt = function() { + return this.getTypedRuleContext(CreatematviewstmtContext,0); +}; + +ExplainablestmtContext.prototype.refreshmatviewstmt = function() { + return this.getTypedRuleContext(RefreshmatviewstmtContext,0); +}; + +ExplainablestmtContext.prototype.executestmt = function() { + return this.getTypedRuleContext(ExecutestmtContext,0); +}; + +ExplainablestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExplainablestmt(this); + } +}; + +ExplainablestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExplainablestmt(this); + } +}; + +ExplainablestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExplainablestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ExplainablestmtContext = ExplainablestmtContext; + +PostgreSQLParser.prototype.explainablestmt = function() { + + var localctx = new ExplainablestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 880, PostgreSQLParser.RULE_explainablestmt); + try { + this.state = 7548; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,370,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7539; + this.selectstmt(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7540; + this.insertstmt(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7541; + this.updatestmt(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 7542; + this.deletestmt(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 7543; + this.declarecursorstmt(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 7544; + this.createasstmt(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 7545; + this.creatematviewstmt(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 7546; + this.refreshmatviewstmt(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 7547; + this.executestmt(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Explain_option_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_explain_option_list; + return this; +} + +Explain_option_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Explain_option_listContext.prototype.constructor = Explain_option_listContext; + +Explain_option_listContext.prototype.explain_option_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Explain_option_elemContext); + } else { + return this.getTypedRuleContext(Explain_option_elemContext,i); + } +}; + +Explain_option_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Explain_option_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExplain_option_list(this); + } +}; + +Explain_option_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExplain_option_list(this); + } +}; + +Explain_option_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExplain_option_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Explain_option_listContext = Explain_option_listContext; + +PostgreSQLParser.prototype.explain_option_list = function() { + + var localctx = new Explain_option_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 882, PostgreSQLParser.RULE_explain_option_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7550; + this.explain_option_elem(); + this.state = 7555; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 7551; + this.match(PostgreSQLParser.COMMA); + this.state = 7552; + this.explain_option_elem(); + this.state = 7557; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Explain_option_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_explain_option_elem; + return this; +} + +Explain_option_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Explain_option_elemContext.prototype.constructor = Explain_option_elemContext; + +Explain_option_elemContext.prototype.explain_option_name = function() { + return this.getTypedRuleContext(Explain_option_nameContext,0); +}; + +Explain_option_elemContext.prototype.explain_option_arg = function() { + return this.getTypedRuleContext(Explain_option_argContext,0); +}; + +Explain_option_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExplain_option_elem(this); + } +}; + +Explain_option_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExplain_option_elem(this); + } +}; + +Explain_option_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExplain_option_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Explain_option_elemContext = Explain_option_elemContext; + +PostgreSQLParser.prototype.explain_option_elem = function() { + + var localctx = new Explain_option_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 884, PostgreSQLParser.RULE_explain_option_elem); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7558; + this.explain_option_name(); + this.state = 7559; + this.explain_option_arg(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Explain_option_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_explain_option_name; + return this; +} + +Explain_option_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Explain_option_nameContext.prototype.constructor = Explain_option_nameContext; + +Explain_option_nameContext.prototype.nonreservedword = function() { + return this.getTypedRuleContext(NonreservedwordContext,0); +}; + +Explain_option_nameContext.prototype.analyze_keyword = function() { + return this.getTypedRuleContext(Analyze_keywordContext,0); +}; + +Explain_option_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExplain_option_name(this); + } +}; + +Explain_option_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExplain_option_name(this); + } +}; + +Explain_option_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExplain_option_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Explain_option_nameContext = Explain_option_nameContext; + +PostgreSQLParser.prototype.explain_option_name = function() { + + var localctx = new Explain_option_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 886, PostgreSQLParser.RULE_explain_option_name); + try { + this.state = 7563; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 7561; + this.nonreservedword(); + break; + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + this.enterOuterAlt(localctx, 2); + this.state = 7562; + this.analyze_keyword(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Explain_option_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_explain_option_arg; + return this; +} + +Explain_option_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Explain_option_argContext.prototype.constructor = Explain_option_argContext; + +Explain_option_argContext.prototype.opt_boolean_or_string = function() { + return this.getTypedRuleContext(Opt_boolean_or_stringContext,0); +}; + +Explain_option_argContext.prototype.numericonly = function() { + return this.getTypedRuleContext(NumericonlyContext,0); +}; + +Explain_option_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExplain_option_arg(this); + } +}; + +Explain_option_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExplain_option_arg(this); + } +}; + +Explain_option_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExplain_option_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Explain_option_argContext = Explain_option_argContext; + +PostgreSQLParser.prototype.explain_option_arg = function() { + + var localctx = new Explain_option_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 888, PostgreSQLParser.RULE_explain_option_arg); + try { + this.state = 7568; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.ON: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 7565; + this.opt_boolean_or_string(); + break; + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + this.enterOuterAlt(localctx, 2); + this.state = 7566; + this.numericonly(); + break; + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function PreparestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_preparestmt; + return this; +} + +PreparestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +PreparestmtContext.prototype.constructor = PreparestmtContext; + +PreparestmtContext.prototype.PREPARE = function() { + return this.getToken(PostgreSQLParser.PREPARE, 0); +}; + +PreparestmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +PreparestmtContext.prototype.prep_type_clause = function() { + return this.getTypedRuleContext(Prep_type_clauseContext,0); +}; + +PreparestmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +PreparestmtContext.prototype.preparablestmt = function() { + return this.getTypedRuleContext(PreparablestmtContext,0); +}; + +PreparestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPreparestmt(this); + } +}; + +PreparestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPreparestmt(this); + } +}; + +PreparestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPreparestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.PreparestmtContext = PreparestmtContext; + +PostgreSQLParser.prototype.preparestmt = function() { + + var localctx = new PreparestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 890, PostgreSQLParser.RULE_preparestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7570; + this.match(PostgreSQLParser.PREPARE); + this.state = 7571; + this.name(); + this.state = 7572; + this.prep_type_clause(); + this.state = 7573; + this.match(PostgreSQLParser.AS); + this.state = 7574; + this.preparablestmt(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Prep_type_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_prep_type_clause; + return this; +} + +Prep_type_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Prep_type_clauseContext.prototype.constructor = Prep_type_clauseContext; + +Prep_type_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Prep_type_clauseContext.prototype.type_list = function() { + return this.getTypedRuleContext(Type_listContext,0); +}; + +Prep_type_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Prep_type_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPrep_type_clause(this); + } +}; + +Prep_type_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPrep_type_clause(this); + } +}; + +Prep_type_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPrep_type_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Prep_type_clauseContext = Prep_type_clauseContext; + +PostgreSQLParser.prototype.prep_type_clause = function() { + + var localctx = new Prep_type_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 892, PostgreSQLParser.RULE_prep_type_clause); + try { + this.state = 7581; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + this.enterOuterAlt(localctx, 1); + this.state = 7576; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7577; + this.type_list(); + this.state = 7578; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.AS: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function PreparablestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_preparablestmt; + return this; +} + +PreparablestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +PreparablestmtContext.prototype.constructor = PreparablestmtContext; + +PreparablestmtContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +PreparablestmtContext.prototype.insertstmt = function() { + return this.getTypedRuleContext(InsertstmtContext,0); +}; + +PreparablestmtContext.prototype.updatestmt = function() { + return this.getTypedRuleContext(UpdatestmtContext,0); +}; + +PreparablestmtContext.prototype.deletestmt = function() { + return this.getTypedRuleContext(DeletestmtContext,0); +}; + +PreparablestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPreparablestmt(this); + } +}; + +PreparablestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPreparablestmt(this); + } +}; + +PreparablestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPreparablestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.PreparablestmtContext = PreparablestmtContext; + +PostgreSQLParser.prototype.preparablestmt = function() { + + var localctx = new PreparablestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 894, PostgreSQLParser.RULE_preparablestmt); + try { + this.state = 7587; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,375,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7583; + this.selectstmt(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7584; + this.insertstmt(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7585; + this.updatestmt(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 7586; + this.deletestmt(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ExecutestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_executestmt; + return this; +} + +ExecutestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ExecutestmtContext.prototype.constructor = ExecutestmtContext; + +ExecutestmtContext.prototype.EXECUTE = function() { + return this.getToken(PostgreSQLParser.EXECUTE, 0); +}; + +ExecutestmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +ExecutestmtContext.prototype.execute_param_clause = function() { + return this.getTypedRuleContext(Execute_param_clauseContext,0); +}; + +ExecutestmtContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +ExecutestmtContext.prototype.opttemp = function() { + return this.getTypedRuleContext(OpttempContext,0); +}; + +ExecutestmtContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +ExecutestmtContext.prototype.create_as_target = function() { + return this.getTypedRuleContext(Create_as_targetContext,0); +}; + +ExecutestmtContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +ExecutestmtContext.prototype.opt_with_data = function() { + return this.getTypedRuleContext(Opt_with_dataContext,0); +}; + +ExecutestmtContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +ExecutestmtContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +ExecutestmtContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +ExecutestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExecutestmt(this); + } +}; + +ExecutestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExecutestmt(this); + } +}; + +ExecutestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExecutestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ExecutestmtContext = ExecutestmtContext; + +PostgreSQLParser.prototype.executestmt = function() { + + var localctx = new ExecutestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 896, PostgreSQLParser.RULE_executestmt); + try { + this.state = 7616; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,376,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7589; + this.match(PostgreSQLParser.EXECUTE); + this.state = 7590; + this.name(); + this.state = 7591; + this.execute_param_clause(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7593; + this.match(PostgreSQLParser.CREATE); + this.state = 7594; + this.opttemp(); + this.state = 7595; + this.match(PostgreSQLParser.TABLE); + this.state = 7596; + this.create_as_target(); + this.state = 7597; + this.match(PostgreSQLParser.AS); + this.state = 7598; + this.match(PostgreSQLParser.EXECUTE); + this.state = 7599; + this.name(); + this.state = 7600; + this.execute_param_clause(); + this.state = 7601; + this.opt_with_data(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7603; + this.match(PostgreSQLParser.CREATE); + this.state = 7604; + this.opttemp(); + this.state = 7605; + this.match(PostgreSQLParser.TABLE); + this.state = 7606; + this.match(PostgreSQLParser.IF_P); + this.state = 7607; + this.match(PostgreSQLParser.NOT); + this.state = 7608; + this.match(PostgreSQLParser.EXISTS); + this.state = 7609; + this.create_as_target(); + this.state = 7610; + this.match(PostgreSQLParser.AS); + this.state = 7611; + this.match(PostgreSQLParser.EXECUTE); + this.state = 7612; + this.name(); + this.state = 7613; + this.execute_param_clause(); + this.state = 7614; + this.opt_with_data(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Execute_param_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_execute_param_clause; + return this; +} + +Execute_param_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Execute_param_clauseContext.prototype.constructor = Execute_param_clauseContext; + +Execute_param_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Execute_param_clauseContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Execute_param_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Execute_param_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExecute_param_clause(this); + } +}; + +Execute_param_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExecute_param_clause(this); + } +}; + +Execute_param_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExecute_param_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Execute_param_clauseContext = Execute_param_clauseContext; + +PostgreSQLParser.prototype.execute_param_clause = function() { + + var localctx = new Execute_param_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 898, PostgreSQLParser.RULE_execute_param_clause); + try { + this.state = 7623; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,377,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7618; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7619; + this.expr_list(); + this.state = 7620; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DeallocatestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_deallocatestmt; + return this; +} + +DeallocatestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DeallocatestmtContext.prototype.constructor = DeallocatestmtContext; + +DeallocatestmtContext.prototype.DEALLOCATE = function() { + return this.getToken(PostgreSQLParser.DEALLOCATE, 0); +}; + +DeallocatestmtContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +DeallocatestmtContext.prototype.PREPARE = function() { + return this.getToken(PostgreSQLParser.PREPARE, 0); +}; + +DeallocatestmtContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +DeallocatestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDeallocatestmt(this); + } +}; + +DeallocatestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDeallocatestmt(this); + } +}; + +DeallocatestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDeallocatestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DeallocatestmtContext = DeallocatestmtContext; + +PostgreSQLParser.prototype.deallocatestmt = function() { + + var localctx = new DeallocatestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 900, PostgreSQLParser.RULE_deallocatestmt); + try { + this.state = 7635; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,378,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7625; + this.match(PostgreSQLParser.DEALLOCATE); + this.state = 7626; + this.name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7627; + this.match(PostgreSQLParser.DEALLOCATE); + this.state = 7628; + this.match(PostgreSQLParser.PREPARE); + this.state = 7629; + this.name(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7630; + this.match(PostgreSQLParser.DEALLOCATE); + this.state = 7631; + this.match(PostgreSQLParser.ALL); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 7632; + this.match(PostgreSQLParser.DEALLOCATE); + this.state = 7633; + this.match(PostgreSQLParser.PREPARE); + this.state = 7634; + this.match(PostgreSQLParser.ALL); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function InsertstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_insertstmt; + return this; +} + +InsertstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +InsertstmtContext.prototype.constructor = InsertstmtContext; + +InsertstmtContext.prototype.opt_with_clause = function() { + return this.getTypedRuleContext(Opt_with_clauseContext,0); +}; + +InsertstmtContext.prototype.INSERT = function() { + return this.getToken(PostgreSQLParser.INSERT, 0); +}; + +InsertstmtContext.prototype.INTO = function() { + return this.getToken(PostgreSQLParser.INTO, 0); +}; + +InsertstmtContext.prototype.insert_target = function() { + return this.getTypedRuleContext(Insert_targetContext,0); +}; + +InsertstmtContext.prototype.insert_rest = function() { + return this.getTypedRuleContext(Insert_restContext,0); +}; + +InsertstmtContext.prototype.opt_on_conflict = function() { + return this.getTypedRuleContext(Opt_on_conflictContext,0); +}; + +InsertstmtContext.prototype.returning_clause = function() { + return this.getTypedRuleContext(Returning_clauseContext,0); +}; + +InsertstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterInsertstmt(this); + } +}; + +InsertstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitInsertstmt(this); + } +}; + +InsertstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitInsertstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.InsertstmtContext = InsertstmtContext; + +PostgreSQLParser.prototype.insertstmt = function() { + + var localctx = new InsertstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 902, PostgreSQLParser.RULE_insertstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7637; + this.opt_with_clause(); + this.state = 7638; + this.match(PostgreSQLParser.INSERT); + this.state = 7639; + this.match(PostgreSQLParser.INTO); + this.state = 7640; + this.insert_target(); + this.state = 7641; + this.insert_rest(); + this.state = 7642; + this.opt_on_conflict(); + this.state = 7643; + this.returning_clause(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Insert_targetContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_insert_target; + return this; +} + +Insert_targetContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Insert_targetContext.prototype.constructor = Insert_targetContext; + +Insert_targetContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +Insert_targetContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Insert_targetContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Insert_targetContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterInsert_target(this); + } +}; + +Insert_targetContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitInsert_target(this); + } +}; + +Insert_targetContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitInsert_target(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Insert_targetContext = Insert_targetContext; + +PostgreSQLParser.prototype.insert_target = function() { + + var localctx = new Insert_targetContext(this, this._ctx, this.state); + this.enterRule(localctx, 904, PostgreSQLParser.RULE_insert_target); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7645; + this.qualified_name(); + this.state = 7648; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.AS) { + this.state = 7646; + this.match(PostgreSQLParser.AS); + this.state = 7647; + this.colid(); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Insert_restContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_insert_rest; + return this; +} + +Insert_restContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Insert_restContext.prototype.constructor = Insert_restContext; + +Insert_restContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +Insert_restContext.prototype.OVERRIDING = function() { + return this.getToken(PostgreSQLParser.OVERRIDING, 0); +}; + +Insert_restContext.prototype.override_kind = function() { + return this.getTypedRuleContext(Override_kindContext,0); +}; + +Insert_restContext.prototype.VALUE_P = function() { + return this.getToken(PostgreSQLParser.VALUE_P, 0); +}; + +Insert_restContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Insert_restContext.prototype.insert_column_list = function() { + return this.getTypedRuleContext(Insert_column_listContext,0); +}; + +Insert_restContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Insert_restContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Insert_restContext.prototype.VALUES = function() { + return this.getToken(PostgreSQLParser.VALUES, 0); +}; + +Insert_restContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterInsert_rest(this); + } +}; + +Insert_restContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitInsert_rest(this); + } +}; + +Insert_restContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitInsert_rest(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Insert_restContext = Insert_restContext; + +PostgreSQLParser.prototype.insert_rest = function() { + + var localctx = new Insert_restContext(this, this._ctx, this.state); + this.enterRule(localctx, 906, PostgreSQLParser.RULE_insert_rest); + var _la = 0; // Token type + try { + this.state = 7669; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,381,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7650; + this.selectstmt(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7651; + this.match(PostgreSQLParser.OVERRIDING); + this.state = 7652; + this.override_kind(); + this.state = 7653; + this.match(PostgreSQLParser.VALUE_P); + this.state = 7654; + this.selectstmt(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7656; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7657; + this.insert_column_list(); + this.state = 7658; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 7663; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OVERRIDING) { + this.state = 7659; + this.match(PostgreSQLParser.OVERRIDING); + this.state = 7660; + this.override_kind(); + this.state = 7661; + this.match(PostgreSQLParser.VALUE_P); + } + + this.state = 7665; + this.selectstmt(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 7667; + this.match(PostgreSQLParser.DEFAULT); + this.state = 7668; + this.match(PostgreSQLParser.VALUES); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Override_kindContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_override_kind; + return this; +} + +Override_kindContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Override_kindContext.prototype.constructor = Override_kindContext; + +Override_kindContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +Override_kindContext.prototype.SYSTEM_P = function() { + return this.getToken(PostgreSQLParser.SYSTEM_P, 0); +}; + +Override_kindContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOverride_kind(this); + } +}; + +Override_kindContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOverride_kind(this); + } +}; + +Override_kindContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOverride_kind(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Override_kindContext = Override_kindContext; + +PostgreSQLParser.prototype.override_kind = function() { + + var localctx = new Override_kindContext(this, this._ctx, this.state); + this.enterRule(localctx, 908, PostgreSQLParser.RULE_override_kind); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7671; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.USER || _la===PostgreSQLParser.SYSTEM_P)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Insert_column_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_insert_column_list; + return this; +} + +Insert_column_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Insert_column_listContext.prototype.constructor = Insert_column_listContext; + +Insert_column_listContext.prototype.insert_column_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Insert_column_itemContext); + } else { + return this.getTypedRuleContext(Insert_column_itemContext,i); + } +}; + +Insert_column_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Insert_column_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterInsert_column_list(this); + } +}; + +Insert_column_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitInsert_column_list(this); + } +}; + +Insert_column_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitInsert_column_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Insert_column_listContext = Insert_column_listContext; + +PostgreSQLParser.prototype.insert_column_list = function() { + + var localctx = new Insert_column_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 910, PostgreSQLParser.RULE_insert_column_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7673; + this.insert_column_item(); + this.state = 7678; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 7674; + this.match(PostgreSQLParser.COMMA); + this.state = 7675; + this.insert_column_item(); + this.state = 7680; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Insert_column_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_insert_column_item; + return this; +} + +Insert_column_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Insert_column_itemContext.prototype.constructor = Insert_column_itemContext; + +Insert_column_itemContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Insert_column_itemContext.prototype.opt_indirection = function() { + return this.getTypedRuleContext(Opt_indirectionContext,0); +}; + +Insert_column_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterInsert_column_item(this); + } +}; + +Insert_column_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitInsert_column_item(this); + } +}; + +Insert_column_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitInsert_column_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Insert_column_itemContext = Insert_column_itemContext; + +PostgreSQLParser.prototype.insert_column_item = function() { + + var localctx = new Insert_column_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 912, PostgreSQLParser.RULE_insert_column_item); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7681; + this.colid(); + this.state = 7682; + this.opt_indirection(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_on_conflictContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_on_conflict; + return this; +} + +Opt_on_conflictContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_on_conflictContext.prototype.constructor = Opt_on_conflictContext; + +Opt_on_conflictContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +Opt_on_conflictContext.prototype.CONFLICT = function() { + return this.getToken(PostgreSQLParser.CONFLICT, 0); +}; + +Opt_on_conflictContext.prototype.opt_conf_expr = function() { + return this.getTypedRuleContext(Opt_conf_exprContext,0); +}; + +Opt_on_conflictContext.prototype.DO = function() { + return this.getToken(PostgreSQLParser.DO, 0); +}; + +Opt_on_conflictContext.prototype.UPDATE = function() { + return this.getToken(PostgreSQLParser.UPDATE, 0); +}; + +Opt_on_conflictContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +Opt_on_conflictContext.prototype.set_clause_list = function() { + return this.getTypedRuleContext(Set_clause_listContext,0); +}; + +Opt_on_conflictContext.prototype.where_clause = function() { + return this.getTypedRuleContext(Where_clauseContext,0); +}; + +Opt_on_conflictContext.prototype.NOTHING = function() { + return this.getToken(PostgreSQLParser.NOTHING, 0); +}; + +Opt_on_conflictContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_on_conflict(this); + } +}; + +Opt_on_conflictContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_on_conflict(this); + } +}; + +Opt_on_conflictContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_on_conflict(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_on_conflictContext = Opt_on_conflictContext; + +PostgreSQLParser.prototype.opt_on_conflict = function() { + + var localctx = new Opt_on_conflictContext(this, this._ctx, this.state); + this.enterRule(localctx, 914, PostgreSQLParser.RULE_opt_on_conflict); + try { + this.state = 7697; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ON: + this.enterOuterAlt(localctx, 1); + this.state = 7684; + this.match(PostgreSQLParser.ON); + this.state = 7685; + this.match(PostgreSQLParser.CONFLICT); + this.state = 7686; + this.opt_conf_expr(); + this.state = 7687; + this.match(PostgreSQLParser.DO); + this.state = 7694; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.UPDATE: + this.state = 7688; + this.match(PostgreSQLParser.UPDATE); + this.state = 7689; + this.match(PostgreSQLParser.SET); + this.state = 7690; + this.set_clause_list(); + this.state = 7691; + this.where_clause(); + break; + case PostgreSQLParser.NOTHING: + this.state = 7693; + this.match(PostgreSQLParser.NOTHING); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_conf_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_conf_expr; + return this; +} + +Opt_conf_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_conf_exprContext.prototype.constructor = Opt_conf_exprContext; + +Opt_conf_exprContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opt_conf_exprContext.prototype.index_params = function() { + return this.getTypedRuleContext(Index_paramsContext,0); +}; + +Opt_conf_exprContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opt_conf_exprContext.prototype.where_clause = function() { + return this.getTypedRuleContext(Where_clauseContext,0); +}; + +Opt_conf_exprContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +Opt_conf_exprContext.prototype.CONSTRAINT = function() { + return this.getToken(PostgreSQLParser.CONSTRAINT, 0); +}; + +Opt_conf_exprContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Opt_conf_exprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_conf_expr(this); + } +}; + +Opt_conf_exprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_conf_expr(this); + } +}; + +Opt_conf_exprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_conf_expr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_conf_exprContext = Opt_conf_exprContext; + +PostgreSQLParser.prototype.opt_conf_expr = function() { + + var localctx = new Opt_conf_exprContext(this, this._ctx, this.state); + this.enterRule(localctx, 916, PostgreSQLParser.RULE_opt_conf_expr); + try { + this.state = 7708; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + this.enterOuterAlt(localctx, 1); + this.state = 7699; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7700; + this.index_params(); + this.state = 7701; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 7702; + this.where_clause(); + break; + case PostgreSQLParser.ON: + this.enterOuterAlt(localctx, 2); + this.state = 7704; + this.match(PostgreSQLParser.ON); + this.state = 7705; + this.match(PostgreSQLParser.CONSTRAINT); + this.state = 7706; + this.name(); + break; + case PostgreSQLParser.DO: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Returning_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_returning_clause; + return this; +} + +Returning_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Returning_clauseContext.prototype.constructor = Returning_clauseContext; + +Returning_clauseContext.prototype.RETURNING = function() { + return this.getToken(PostgreSQLParser.RETURNING, 0); +}; + +Returning_clauseContext.prototype.target_list = function() { + return this.getTypedRuleContext(Target_listContext,0); +}; + +Returning_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReturning_clause(this); + } +}; + +Returning_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReturning_clause(this); + } +}; + +Returning_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReturning_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Returning_clauseContext = Returning_clauseContext; + +PostgreSQLParser.prototype.returning_clause = function() { + + var localctx = new Returning_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 918, PostgreSQLParser.RULE_returning_clause); + try { + this.state = 7713; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.RETURNING: + this.enterOuterAlt(localctx, 1); + this.state = 7710; + this.match(PostgreSQLParser.RETURNING); + this.state = 7711; + this.target_list(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DeletestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_deletestmt; + return this; +} + +DeletestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DeletestmtContext.prototype.constructor = DeletestmtContext; + +DeletestmtContext.prototype.opt_with_clause = function() { + return this.getTypedRuleContext(Opt_with_clauseContext,0); +}; + +DeletestmtContext.prototype.DELETE_P = function() { + return this.getToken(PostgreSQLParser.DELETE_P, 0); +}; + +DeletestmtContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +DeletestmtContext.prototype.relation_expr_opt_alias = function() { + return this.getTypedRuleContext(Relation_expr_opt_aliasContext,0); +}; + +DeletestmtContext.prototype.using_clause = function() { + return this.getTypedRuleContext(Using_clauseContext,0); +}; + +DeletestmtContext.prototype.where_or_current_clause = function() { + return this.getTypedRuleContext(Where_or_current_clauseContext,0); +}; + +DeletestmtContext.prototype.returning_clause = function() { + return this.getTypedRuleContext(Returning_clauseContext,0); +}; + +DeletestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDeletestmt(this); + } +}; + +DeletestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDeletestmt(this); + } +}; + +DeletestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDeletestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DeletestmtContext = DeletestmtContext; + +PostgreSQLParser.prototype.deletestmt = function() { + + var localctx = new DeletestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 920, PostgreSQLParser.RULE_deletestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7715; + this.opt_with_clause(); + this.state = 7716; + this.match(PostgreSQLParser.DELETE_P); + this.state = 7717; + this.match(PostgreSQLParser.FROM); + this.state = 7718; + this.relation_expr_opt_alias(); + this.state = 7719; + this.using_clause(); + this.state = 7720; + this.where_or_current_clause(); + this.state = 7721; + this.returning_clause(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Using_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_using_clause; + return this; +} + +Using_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Using_clauseContext.prototype.constructor = Using_clauseContext; + +Using_clauseContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Using_clauseContext.prototype.from_list = function() { + return this.getTypedRuleContext(From_listContext,0); +}; + +Using_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterUsing_clause(this); + } +}; + +Using_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitUsing_clause(this); + } +}; + +Using_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitUsing_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Using_clauseContext = Using_clauseContext; + +PostgreSQLParser.prototype.using_clause = function() { + + var localctx = new Using_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 922, PostgreSQLParser.RULE_using_clause); + try { + this.state = 7726; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + this.state = 7723; + this.match(PostgreSQLParser.USING); + this.state = 7724; + this.from_list(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function LockstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_lockstmt; + return this; +} + +LockstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +LockstmtContext.prototype.constructor = LockstmtContext; + +LockstmtContext.prototype.LOCK_P = function() { + return this.getToken(PostgreSQLParser.LOCK_P, 0); +}; + +LockstmtContext.prototype.opt_table = function() { + return this.getTypedRuleContext(Opt_tableContext,0); +}; + +LockstmtContext.prototype.relation_expr_list = function() { + return this.getTypedRuleContext(Relation_expr_listContext,0); +}; + +LockstmtContext.prototype.opt_lock = function() { + return this.getTypedRuleContext(Opt_lockContext,0); +}; + +LockstmtContext.prototype.opt_nowait = function() { + return this.getTypedRuleContext(Opt_nowaitContext,0); +}; + +LockstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterLockstmt(this); + } +}; + +LockstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitLockstmt(this); + } +}; + +LockstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitLockstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.LockstmtContext = LockstmtContext; + +PostgreSQLParser.prototype.lockstmt = function() { + + var localctx = new LockstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 924, PostgreSQLParser.RULE_lockstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7728; + this.match(PostgreSQLParser.LOCK_P); + this.state = 7729; + this.opt_table(); + this.state = 7730; + this.relation_expr_list(); + this.state = 7731; + this.opt_lock(); + this.state = 7732; + this.opt_nowait(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_lockContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_lock; + return this; +} + +Opt_lockContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_lockContext.prototype.constructor = Opt_lockContext; + +Opt_lockContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +Opt_lockContext.prototype.lock_type = function() { + return this.getTypedRuleContext(Lock_typeContext,0); +}; + +Opt_lockContext.prototype.MODE = function() { + return this.getToken(PostgreSQLParser.MODE, 0); +}; + +Opt_lockContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_lock(this); + } +}; + +Opt_lockContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_lock(this); + } +}; + +Opt_lockContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_lock(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_lockContext = Opt_lockContext; + +PostgreSQLParser.prototype.opt_lock = function() { + + var localctx = new Opt_lockContext(this, this._ctx, this.state); + this.enterRule(localctx, 926, PostgreSQLParser.RULE_opt_lock); + try { + this.state = 7739; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.IN_P: + this.enterOuterAlt(localctx, 1); + this.state = 7734; + this.match(PostgreSQLParser.IN_P); + this.state = 7735; + this.lock_type(); + this.state = 7736; + this.match(PostgreSQLParser.MODE); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Lock_typeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_lock_type; + return this; +} + +Lock_typeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Lock_typeContext.prototype.constructor = Lock_typeContext; + +Lock_typeContext.prototype.ACCESS = function() { + return this.getToken(PostgreSQLParser.ACCESS, 0); +}; + +Lock_typeContext.prototype.SHARE = function() { + return this.getToken(PostgreSQLParser.SHARE, 0); +}; + +Lock_typeContext.prototype.EXCLUSIVE = function() { + return this.getToken(PostgreSQLParser.EXCLUSIVE, 0); +}; + +Lock_typeContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +Lock_typeContext.prototype.UPDATE = function() { + return this.getToken(PostgreSQLParser.UPDATE, 0); +}; + +Lock_typeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterLock_type(this); + } +}; + +Lock_typeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitLock_type(this); + } +}; + +Lock_typeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitLock_type(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Lock_typeContext = Lock_typeContext; + +PostgreSQLParser.prototype.lock_type = function() { + + var localctx = new Lock_typeContext(this, this._ctx, this.state); + this.enterRule(localctx, 928, PostgreSQLParser.RULE_lock_type); + var _la = 0; // Token type + try { + this.state = 7753; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ACCESS: + this.enterOuterAlt(localctx, 1); + this.state = 7741; + this.match(PostgreSQLParser.ACCESS); + this.state = 7742; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.EXCLUSIVE || _la===PostgreSQLParser.SHARE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + case PostgreSQLParser.ROW: + this.enterOuterAlt(localctx, 2); + this.state = 7743; + this.match(PostgreSQLParser.ROW); + this.state = 7744; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.EXCLUSIVE || _la===PostgreSQLParser.SHARE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + case PostgreSQLParser.SHARE: + this.enterOuterAlt(localctx, 3); + this.state = 7745; + this.match(PostgreSQLParser.SHARE); + this.state = 7750; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case PostgreSQLParser.UPDATE: + this.state = 7746; + this.match(PostgreSQLParser.UPDATE); + this.state = 7747; + this.match(PostgreSQLParser.EXCLUSIVE); + break; + case PostgreSQLParser.ROW: + this.state = 7748; + this.match(PostgreSQLParser.ROW); + this.state = 7749; + this.match(PostgreSQLParser.EXCLUSIVE); + break; + case PostgreSQLParser.MODE: + break; + default: + break; + } + break; + case PostgreSQLParser.EXCLUSIVE: + this.enterOuterAlt(localctx, 4); + this.state = 7752; + this.match(PostgreSQLParser.EXCLUSIVE); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_nowaitContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_nowait; + return this; +} + +Opt_nowaitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_nowaitContext.prototype.constructor = Opt_nowaitContext; + +Opt_nowaitContext.prototype.NOWAIT = function() { + return this.getToken(PostgreSQLParser.NOWAIT, 0); +}; + +Opt_nowaitContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_nowait(this); + } +}; + +Opt_nowaitContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_nowait(this); + } +}; + +Opt_nowaitContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_nowait(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_nowaitContext = Opt_nowaitContext; + +PostgreSQLParser.prototype.opt_nowait = function() { + + var localctx = new Opt_nowaitContext(this, this._ctx, this.state); + this.enterRule(localctx, 930, PostgreSQLParser.RULE_opt_nowait); + try { + this.state = 7757; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NOWAIT: + this.enterOuterAlt(localctx, 1); + this.state = 7755; + this.match(PostgreSQLParser.NOWAIT); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_nowait_or_skipContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_nowait_or_skip; + return this; +} + +Opt_nowait_or_skipContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_nowait_or_skipContext.prototype.constructor = Opt_nowait_or_skipContext; + +Opt_nowait_or_skipContext.prototype.NOWAIT = function() { + return this.getToken(PostgreSQLParser.NOWAIT, 0); +}; + +Opt_nowait_or_skipContext.prototype.SKIP_P = function() { + return this.getToken(PostgreSQLParser.SKIP_P, 0); +}; + +Opt_nowait_or_skipContext.prototype.LOCKED = function() { + return this.getToken(PostgreSQLParser.LOCKED, 0); +}; + +Opt_nowait_or_skipContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_nowait_or_skip(this); + } +}; + +Opt_nowait_or_skipContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_nowait_or_skip(this); + } +}; + +Opt_nowait_or_skipContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_nowait_or_skip(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_nowait_or_skipContext = Opt_nowait_or_skipContext; + +PostgreSQLParser.prototype.opt_nowait_or_skip = function() { + + var localctx = new Opt_nowait_or_skipContext(this, this._ctx, this.state); + this.enterRule(localctx, 932, PostgreSQLParser.RULE_opt_nowait_or_skip); + try { + this.state = 7763; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NOWAIT: + this.enterOuterAlt(localctx, 1); + this.state = 7759; + this.match(PostgreSQLParser.NOWAIT); + break; + case PostgreSQLParser.SKIP_P: + this.enterOuterAlt(localctx, 2); + this.state = 7760; + this.match(PostgreSQLParser.SKIP_P); + this.state = 7761; + this.match(PostgreSQLParser.LOCKED); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function UpdatestmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_updatestmt; + return this; +} + +UpdatestmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +UpdatestmtContext.prototype.constructor = UpdatestmtContext; + +UpdatestmtContext.prototype.opt_with_clause = function() { + return this.getTypedRuleContext(Opt_with_clauseContext,0); +}; + +UpdatestmtContext.prototype.UPDATE = function() { + return this.getToken(PostgreSQLParser.UPDATE, 0); +}; + +UpdatestmtContext.prototype.relation_expr_opt_alias = function() { + return this.getTypedRuleContext(Relation_expr_opt_aliasContext,0); +}; + +UpdatestmtContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +UpdatestmtContext.prototype.set_clause_list = function() { + return this.getTypedRuleContext(Set_clause_listContext,0); +}; + +UpdatestmtContext.prototype.from_clause = function() { + return this.getTypedRuleContext(From_clauseContext,0); +}; + +UpdatestmtContext.prototype.where_or_current_clause = function() { + return this.getTypedRuleContext(Where_or_current_clauseContext,0); +}; + +UpdatestmtContext.prototype.returning_clause = function() { + return this.getTypedRuleContext(Returning_clauseContext,0); +}; + +UpdatestmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterUpdatestmt(this); + } +}; + +UpdatestmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitUpdatestmt(this); + } +}; + +UpdatestmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitUpdatestmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.UpdatestmtContext = UpdatestmtContext; + +PostgreSQLParser.prototype.updatestmt = function() { + + var localctx = new UpdatestmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 934, PostgreSQLParser.RULE_updatestmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7765; + this.opt_with_clause(); + this.state = 7766; + this.match(PostgreSQLParser.UPDATE); + this.state = 7767; + this.relation_expr_opt_alias(); + this.state = 7768; + this.match(PostgreSQLParser.SET); + this.state = 7769; + this.set_clause_list(); + this.state = 7770; + this.from_clause(); + this.state = 7771; + this.where_or_current_clause(); + this.state = 7772; + this.returning_clause(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Set_clause_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_set_clause_list; + return this; +} + +Set_clause_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Set_clause_listContext.prototype.constructor = Set_clause_listContext; + +Set_clause_listContext.prototype.set_clause = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Set_clauseContext); + } else { + return this.getTypedRuleContext(Set_clauseContext,i); + } +}; + +Set_clause_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Set_clause_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSet_clause_list(this); + } +}; + +Set_clause_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSet_clause_list(this); + } +}; + +Set_clause_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSet_clause_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Set_clause_listContext = Set_clause_listContext; + +PostgreSQLParser.prototype.set_clause_list = function() { + + var localctx = new Set_clause_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 936, PostgreSQLParser.RULE_set_clause_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7774; + this.set_clause(); + this.state = 7779; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 7775; + this.match(PostgreSQLParser.COMMA); + this.state = 7776; + this.set_clause(); + this.state = 7781; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Set_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_set_clause; + return this; +} + +Set_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Set_clauseContext.prototype.constructor = Set_clauseContext; + +Set_clauseContext.prototype.set_target = function() { + return this.getTypedRuleContext(Set_targetContext,0); +}; + +Set_clauseContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +Set_clauseContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Set_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Set_clauseContext.prototype.set_target_list = function() { + return this.getTypedRuleContext(Set_target_listContext,0); +}; + +Set_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Set_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSet_clause(this); + } +}; + +Set_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSet_clause(this); + } +}; + +Set_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSet_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Set_clauseContext = Set_clauseContext; + +PostgreSQLParser.prototype.set_clause = function() { + + var localctx = new Set_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 938, PostgreSQLParser.RULE_set_clause); + try { + this.state = 7792; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 7782; + this.set_target(); + this.state = 7783; + this.match(PostgreSQLParser.EQUAL); + this.state = 7784; + this.a_expr(); + break; + case PostgreSQLParser.OPEN_PAREN: + this.enterOuterAlt(localctx, 2); + this.state = 7786; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7787; + this.set_target_list(); + this.state = 7788; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 7789; + this.match(PostgreSQLParser.EQUAL); + this.state = 7790; + this.a_expr(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Set_targetContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_set_target; + return this; +} + +Set_targetContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Set_targetContext.prototype.constructor = Set_targetContext; + +Set_targetContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Set_targetContext.prototype.opt_indirection = function() { + return this.getTypedRuleContext(Opt_indirectionContext,0); +}; + +Set_targetContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSet_target(this); + } +}; + +Set_targetContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSet_target(this); + } +}; + +Set_targetContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSet_target(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Set_targetContext = Set_targetContext; + +PostgreSQLParser.prototype.set_target = function() { + + var localctx = new Set_targetContext(this, this._ctx, this.state); + this.enterRule(localctx, 940, PostgreSQLParser.RULE_set_target); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7794; + this.colid(); + this.state = 7795; + this.opt_indirection(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Set_target_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_set_target_list; + return this; +} + +Set_target_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Set_target_listContext.prototype.constructor = Set_target_listContext; + +Set_target_listContext.prototype.set_target = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Set_targetContext); + } else { + return this.getTypedRuleContext(Set_targetContext,i); + } +}; + +Set_target_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Set_target_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSet_target_list(this); + } +}; + +Set_target_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSet_target_list(this); + } +}; + +Set_target_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSet_target_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Set_target_listContext = Set_target_listContext; + +PostgreSQLParser.prototype.set_target_list = function() { + + var localctx = new Set_target_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 942, PostgreSQLParser.RULE_set_target_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7797; + this.set_target(); + this.state = 7802; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 7798; + this.match(PostgreSQLParser.COMMA); + this.state = 7799; + this.set_target(); + this.state = 7804; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function DeclarecursorstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_declarecursorstmt; + return this; +} + +DeclarecursorstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +DeclarecursorstmtContext.prototype.constructor = DeclarecursorstmtContext; + +DeclarecursorstmtContext.prototype.DECLARE = function() { + return this.getToken(PostgreSQLParser.DECLARE, 0); +}; + +DeclarecursorstmtContext.prototype.cursor_name = function() { + return this.getTypedRuleContext(Cursor_nameContext,0); +}; + +DeclarecursorstmtContext.prototype.cursor_options = function() { + return this.getTypedRuleContext(Cursor_optionsContext,0); +}; + +DeclarecursorstmtContext.prototype.CURSOR = function() { + return this.getToken(PostgreSQLParser.CURSOR, 0); +}; + +DeclarecursorstmtContext.prototype.opt_hold = function() { + return this.getTypedRuleContext(Opt_holdContext,0); +}; + +DeclarecursorstmtContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +DeclarecursorstmtContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +DeclarecursorstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDeclarecursorstmt(this); + } +}; + +DeclarecursorstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDeclarecursorstmt(this); + } +}; + +DeclarecursorstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDeclarecursorstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.DeclarecursorstmtContext = DeclarecursorstmtContext; + +PostgreSQLParser.prototype.declarecursorstmt = function() { + + var localctx = new DeclarecursorstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 944, PostgreSQLParser.RULE_declarecursorstmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7805; + this.match(PostgreSQLParser.DECLARE); + this.state = 7806; + this.cursor_name(); + this.state = 7807; + this.cursor_options(); + this.state = 7808; + this.match(PostgreSQLParser.CURSOR); + this.state = 7809; + this.opt_hold(); + this.state = 7810; + this.match(PostgreSQLParser.FOR); + this.state = 7811; + this.selectstmt(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Cursor_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_cursor_name; + return this; +} + +Cursor_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Cursor_nameContext.prototype.constructor = Cursor_nameContext; + +Cursor_nameContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Cursor_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCursor_name(this); + } +}; + +Cursor_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCursor_name(this); + } +}; + +Cursor_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCursor_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Cursor_nameContext = Cursor_nameContext; + +PostgreSQLParser.prototype.cursor_name = function() { + + var localctx = new Cursor_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 946, PostgreSQLParser.RULE_cursor_name); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7813; + this.name(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Cursor_optionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_cursor_options; + return this; +} + +Cursor_optionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Cursor_optionsContext.prototype.constructor = Cursor_optionsContext; + +Cursor_optionsContext.prototype.NO = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.NO); + } else { + return this.getToken(PostgreSQLParser.NO, i); + } +}; + + +Cursor_optionsContext.prototype.SCROLL = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.SCROLL); + } else { + return this.getToken(PostgreSQLParser.SCROLL, i); + } +}; + + +Cursor_optionsContext.prototype.BINARY = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.BINARY); + } else { + return this.getToken(PostgreSQLParser.BINARY, i); + } +}; + + +Cursor_optionsContext.prototype.INSENSITIVE = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.INSENSITIVE); + } else { + return this.getToken(PostgreSQLParser.INSENSITIVE, i); + } +}; + + +Cursor_optionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCursor_options(this); + } +}; + +Cursor_optionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCursor_options(this); + } +}; + +Cursor_optionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCursor_options(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Cursor_optionsContext = Cursor_optionsContext; + +PostgreSQLParser.prototype.cursor_options = function() { + + var localctx = new Cursor_optionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 948, PostgreSQLParser.RULE_cursor_options); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7822; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.BINARY || _la===PostgreSQLParser.INSENSITIVE || _la===PostgreSQLParser.NO || _la===PostgreSQLParser.SCROLL) { + this.state = 7820; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NO: + this.state = 7815; + this.match(PostgreSQLParser.NO); + this.state = 7816; + this.match(PostgreSQLParser.SCROLL); + break; + case PostgreSQLParser.SCROLL: + this.state = 7817; + this.match(PostgreSQLParser.SCROLL); + break; + case PostgreSQLParser.BINARY: + this.state = 7818; + this.match(PostgreSQLParser.BINARY); + break; + case PostgreSQLParser.INSENSITIVE: + this.state = 7819; + this.match(PostgreSQLParser.INSENSITIVE); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 7824; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_holdContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_hold; + return this; +} + +Opt_holdContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_holdContext.prototype.constructor = Opt_holdContext; + +Opt_holdContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Opt_holdContext.prototype.HOLD = function() { + return this.getToken(PostgreSQLParser.HOLD, 0); +}; + +Opt_holdContext.prototype.WITHOUT = function() { + return this.getToken(PostgreSQLParser.WITHOUT, 0); +}; + +Opt_holdContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_hold(this); + } +}; + +Opt_holdContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_hold(this); + } +}; + +Opt_holdContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_hold(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_holdContext = Opt_holdContext; + +PostgreSQLParser.prototype.opt_hold = function() { + + var localctx = new Opt_holdContext(this, this._ctx, this.state); + this.enterRule(localctx, 950, PostgreSQLParser.RULE_opt_hold); + try { + this.state = 7830; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FOR: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.WITH: + this.enterOuterAlt(localctx, 2); + this.state = 7826; + this.match(PostgreSQLParser.WITH); + this.state = 7827; + this.match(PostgreSQLParser.HOLD); + break; + case PostgreSQLParser.WITHOUT: + this.enterOuterAlt(localctx, 3); + this.state = 7828; + this.match(PostgreSQLParser.WITHOUT); + this.state = 7829; + this.match(PostgreSQLParser.HOLD); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function SelectstmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_selectstmt; + return this; +} + +SelectstmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +SelectstmtContext.prototype.constructor = SelectstmtContext; + +SelectstmtContext.prototype.select_no_parens = function() { + return this.getTypedRuleContext(Select_no_parensContext,0); +}; + +SelectstmtContext.prototype.select_with_parens = function() { + return this.getTypedRuleContext(Select_with_parensContext,0); +}; + +SelectstmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSelectstmt(this); + } +}; + +SelectstmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSelectstmt(this); + } +}; + +SelectstmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSelectstmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.SelectstmtContext = SelectstmtContext; + +PostgreSQLParser.prototype.selectstmt = function() { + + var localctx = new SelectstmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 952, PostgreSQLParser.RULE_selectstmt); + try { + this.state = 7834; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,399,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7832; + this.select_no_parens(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7833; + this.select_with_parens(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Select_with_parensContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_select_with_parens; + return this; +} + +Select_with_parensContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Select_with_parensContext.prototype.constructor = Select_with_parensContext; + +Select_with_parensContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Select_with_parensContext.prototype.select_no_parens = function() { + return this.getTypedRuleContext(Select_no_parensContext,0); +}; + +Select_with_parensContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Select_with_parensContext.prototype.select_with_parens = function() { + return this.getTypedRuleContext(Select_with_parensContext,0); +}; + +Select_with_parensContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSelect_with_parens(this); + } +}; + +Select_with_parensContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSelect_with_parens(this); + } +}; + +Select_with_parensContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSelect_with_parens(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Select_with_parensContext = Select_with_parensContext; + +PostgreSQLParser.prototype.select_with_parens = function() { + + var localctx = new Select_with_parensContext(this, this._ctx, this.state); + this.enterRule(localctx, 954, PostgreSQLParser.RULE_select_with_parens); + try { + this.state = 7844; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,400,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7836; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7837; + this.select_no_parens(); + this.state = 7838; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7840; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7841; + this.select_with_parens(); + this.state = 7842; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Select_no_parensContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_select_no_parens; + return this; +} + +Select_no_parensContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Select_no_parensContext.prototype.constructor = Select_no_parensContext; + +Select_no_parensContext.prototype.select_clause = function() { + return this.getTypedRuleContext(Select_clauseContext,0); +}; + +Select_no_parensContext.prototype.opt_sort_clause = function() { + return this.getTypedRuleContext(Opt_sort_clauseContext,0); +}; + +Select_no_parensContext.prototype.for_locking_clause = function() { + return this.getTypedRuleContext(For_locking_clauseContext,0); +}; + +Select_no_parensContext.prototype.opt_select_limit = function() { + return this.getTypedRuleContext(Opt_select_limitContext,0); +}; + +Select_no_parensContext.prototype.select_limit = function() { + return this.getTypedRuleContext(Select_limitContext,0); +}; + +Select_no_parensContext.prototype.opt_for_locking_clause = function() { + return this.getTypedRuleContext(Opt_for_locking_clauseContext,0); +}; + +Select_no_parensContext.prototype.with_clause = function() { + return this.getTypedRuleContext(With_clauseContext,0); +}; + +Select_no_parensContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSelect_no_parens(this); + } +}; + +Select_no_parensContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSelect_no_parens(this); + } +}; + +Select_no_parensContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSelect_no_parens(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Select_no_parensContext = Select_no_parensContext; + +PostgreSQLParser.prototype.select_no_parens = function() { + + var localctx = new Select_no_parensContext(this, this._ctx, this.state); + this.enterRule(localctx, 956, PostgreSQLParser.RULE_select_no_parens); + try { + this.state = 7867; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.VALUES: + this.enterOuterAlt(localctx, 1); + this.state = 7846; + this.select_clause(); + this.state = 7847; + this.opt_sort_clause(); + this.state = 7854; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,401,this._ctx); + if(la_===1) { + this.state = 7848; + this.for_locking_clause(); + this.state = 7849; + this.opt_select_limit(); + + } else if(la_===2) { + this.state = 7851; + this.select_limit(); + this.state = 7852; + this.opt_for_locking_clause(); + + } + break; + case PostgreSQLParser.WITH: + this.enterOuterAlt(localctx, 2); + this.state = 7856; + this.with_clause(); + this.state = 7857; + this.select_clause(); + this.state = 7858; + this.opt_sort_clause(); + this.state = 7865; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,402,this._ctx); + if(la_===1) { + this.state = 7859; + this.for_locking_clause(); + this.state = 7860; + this.opt_select_limit(); + + } else if(la_===2) { + this.state = 7862; + this.select_limit(); + this.state = 7863; + this.opt_for_locking_clause(); + + } + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Select_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_select_clause; + return this; +} + +Select_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Select_clauseContext.prototype.constructor = Select_clauseContext; + +Select_clauseContext.prototype.simple_select = function() { + return this.getTypedRuleContext(Simple_selectContext,0); +}; + +Select_clauseContext.prototype.select_with_parens = function() { + return this.getTypedRuleContext(Select_with_parensContext,0); +}; + +Select_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSelect_clause(this); + } +}; + +Select_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSelect_clause(this); + } +}; + +Select_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSelect_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Select_clauseContext = Select_clauseContext; + +PostgreSQLParser.prototype.select_clause = function() { + + var localctx = new Select_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 958, PostgreSQLParser.RULE_select_clause); + try { + this.state = 7871; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,404,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7869; + this.simple_select(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7870; + this.select_with_parens(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Simple_selectContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_simple_select; + return this; +} + +Simple_selectContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Simple_selectContext.prototype.constructor = Simple_selectContext; + +Simple_selectContext.prototype.SELECT = function() { + return this.getToken(PostgreSQLParser.SELECT, 0); +}; + +Simple_selectContext.prototype.into_clause = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Into_clauseContext); + } else { + return this.getTypedRuleContext(Into_clauseContext,i); + } +}; + +Simple_selectContext.prototype.from_clause = function() { + return this.getTypedRuleContext(From_clauseContext,0); +}; + +Simple_selectContext.prototype.where_clause = function() { + return this.getTypedRuleContext(Where_clauseContext,0); +}; + +Simple_selectContext.prototype.group_clause = function() { + return this.getTypedRuleContext(Group_clauseContext,0); +}; + +Simple_selectContext.prototype.having_clause = function() { + return this.getTypedRuleContext(Having_clauseContext,0); +}; + +Simple_selectContext.prototype.window_clause = function() { + return this.getTypedRuleContext(Window_clauseContext,0); +}; + +Simple_selectContext.prototype.values_clause = function() { + return this.getTypedRuleContext(Values_clauseContext,0); +}; + +Simple_selectContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +Simple_selectContext.prototype.relation_expr = function() { + return this.getTypedRuleContext(Relation_exprContext,0); +}; + +Simple_selectContext.prototype.select_with_parens = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Select_with_parensContext); + } else { + return this.getTypedRuleContext(Select_with_parensContext,i); + } +}; + +Simple_selectContext.prototype.set_operator_with_all_or_distinct = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Set_operator_with_all_or_distinctContext); + } else { + return this.getTypedRuleContext(Set_operator_with_all_or_distinctContext,i); + } +}; + +Simple_selectContext.prototype.opt_all_clause = function() { + return this.getTypedRuleContext(Opt_all_clauseContext,0); +}; + +Simple_selectContext.prototype.opt_target_list = function() { + return this.getTypedRuleContext(Opt_target_listContext,0); +}; + +Simple_selectContext.prototype.distinct_clause = function() { + return this.getTypedRuleContext(Distinct_clauseContext,0); +}; + +Simple_selectContext.prototype.target_list = function() { + return this.getTypedRuleContext(Target_listContext,0); +}; + +Simple_selectContext.prototype.simple_select = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Simple_selectContext); + } else { + return this.getTypedRuleContext(Simple_selectContext,i); + } +}; + +Simple_selectContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSimple_select(this); + } +}; + +Simple_selectContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSimple_select(this); + } +}; + +Simple_selectContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSimple_select(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Simple_selectContext = Simple_selectContext; + +PostgreSQLParser.prototype.simple_select = function() { + + var localctx = new Simple_selectContext(this, this._ctx, this.state); + this.enterRule(localctx, 960, PostgreSQLParser.RULE_simple_select); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7899; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SELECT: + this.state = 7873; + this.match(PostgreSQLParser.SELECT); + this.state = 7881; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.STAR: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.Operator: + case PostgreSQLParser.ALL: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.FROM: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.GROUP_P: + case PostgreSQLParser.HAVING: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNION: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.MetaCommand: + case PostgreSQLParser.EscapeStringConstant: + this.state = 7874; + this.opt_all_clause(); + this.state = 7875; + this.into_clause(); + this.state = 7876; + this.opt_target_list(); + break; + case PostgreSQLParser.DISTINCT: + this.state = 7878; + this.distinct_clause(); + this.state = 7879; + this.target_list(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 7883; + this.into_clause(); + this.state = 7884; + this.from_clause(); + this.state = 7885; + this.where_clause(); + this.state = 7886; + this.group_clause(); + this.state = 7887; + this.having_clause(); + this.state = 7888; + this.window_clause(); + break; + case PostgreSQLParser.VALUES: + this.state = 7890; + this.values_clause(); + break; + case PostgreSQLParser.TABLE: + this.state = 7891; + this.match(PostgreSQLParser.TABLE); + this.state = 7892; + this.relation_expr(); + break; + case PostgreSQLParser.OPEN_PAREN: + this.state = 7893; + this.select_with_parens(); + this.state = 7894; + this.set_operator_with_all_or_distinct(); + this.state = 7897; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,406,this._ctx); + switch(la_) { + case 1: + this.state = 7895; + this.simple_select(); + break; + + case 2: + this.state = 7896; + this.select_with_parens(); + break; + + } + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 7908; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,409,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 7901; + this.set_operator_with_all_or_distinct(); + this.state = 7904; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,408,this._ctx); + switch(la_) { + case 1: + this.state = 7902; + this.simple_select(); + break; + + case 2: + this.state = 7903; + this.select_with_parens(); + break; + + } + } + this.state = 7910; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,409,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Set_operatorContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_set_operator; + return this; +} + +Set_operatorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Set_operatorContext.prototype.constructor = Set_operatorContext; + + + +Set_operatorContext.prototype.copyFrom = function(ctx) { + antlr4.ParserRuleContext.prototype.copyFrom.call(this, ctx); +}; + + +function IntersectContext(parser, ctx) { + Set_operatorContext.call(this, parser); + Set_operatorContext.prototype.copyFrom.call(this, ctx); + return this; +} + +IntersectContext.prototype = Object.create(Set_operatorContext.prototype); +IntersectContext.prototype.constructor = IntersectContext; + +PostgreSQLParser.IntersectContext = IntersectContext; + +IntersectContext.prototype.INTERSECT = function() { + return this.getToken(PostgreSQLParser.INTERSECT, 0); +}; +IntersectContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIntersect(this); + } +}; + +IntersectContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIntersect(this); + } +}; + +IntersectContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIntersect(this); + } else { + return visitor.visitChildren(this); + } +}; + + +function ExceptContext(parser, ctx) { + Set_operatorContext.call(this, parser); + Set_operatorContext.prototype.copyFrom.call(this, ctx); + return this; +} + +ExceptContext.prototype = Object.create(Set_operatorContext.prototype); +ExceptContext.prototype.constructor = ExceptContext; + +PostgreSQLParser.ExceptContext = ExceptContext; + +ExceptContext.prototype.EXCEPT = function() { + return this.getToken(PostgreSQLParser.EXCEPT, 0); +}; +ExceptContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExcept(this); + } +}; + +ExceptContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExcept(this); + } +}; + +ExceptContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExcept(this); + } else { + return visitor.visitChildren(this); + } +}; + + +function UnionContext(parser, ctx) { + Set_operatorContext.call(this, parser); + Set_operatorContext.prototype.copyFrom.call(this, ctx); + return this; +} + +UnionContext.prototype = Object.create(Set_operatorContext.prototype); +UnionContext.prototype.constructor = UnionContext; + +PostgreSQLParser.UnionContext = UnionContext; + +UnionContext.prototype.UNION = function() { + return this.getToken(PostgreSQLParser.UNION, 0); +}; +UnionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterUnion(this); + } +}; + +UnionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitUnion(this); + } +}; + +UnionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitUnion(this); + } else { + return visitor.visitChildren(this); + } +}; + + + +PostgreSQLParser.Set_operatorContext = Set_operatorContext; + +PostgreSQLParser.prototype.set_operator = function() { + + var localctx = new Set_operatorContext(this, this._ctx, this.state); + this.enterRule(localctx, 962, PostgreSQLParser.RULE_set_operator); + try { + this.state = 7914; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.UNION: + localctx = new UnionContext(this, localctx); + this.enterOuterAlt(localctx, 1); + this.state = 7911; + this.match(PostgreSQLParser.UNION); + break; + case PostgreSQLParser.INTERSECT: + localctx = new IntersectContext(this, localctx); + this.enterOuterAlt(localctx, 2); + this.state = 7912; + this.match(PostgreSQLParser.INTERSECT); + break; + case PostgreSQLParser.EXCEPT: + localctx = new ExceptContext(this, localctx); + this.enterOuterAlt(localctx, 3); + this.state = 7913; + this.match(PostgreSQLParser.EXCEPT); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Set_operator_with_all_or_distinctContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_set_operator_with_all_or_distinct; + return this; +} + +Set_operator_with_all_or_distinctContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Set_operator_with_all_or_distinctContext.prototype.constructor = Set_operator_with_all_or_distinctContext; + +Set_operator_with_all_or_distinctContext.prototype.set_operator = function() { + return this.getTypedRuleContext(Set_operatorContext,0); +}; + +Set_operator_with_all_or_distinctContext.prototype.all_or_distinct = function() { + return this.getTypedRuleContext(All_or_distinctContext,0); +}; + +Set_operator_with_all_or_distinctContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSet_operator_with_all_or_distinct(this); + } +}; + +Set_operator_with_all_or_distinctContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSet_operator_with_all_or_distinct(this); + } +}; + +Set_operator_with_all_or_distinctContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSet_operator_with_all_or_distinct(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Set_operator_with_all_or_distinctContext = Set_operator_with_all_or_distinctContext; + +PostgreSQLParser.prototype.set_operator_with_all_or_distinct = function() { + + var localctx = new Set_operator_with_all_or_distinctContext(this, this._ctx, this.state); + this.enterRule(localctx, 964, PostgreSQLParser.RULE_set_operator_with_all_or_distinct); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7916; + this.set_operator(); + this.state = 7917; + this.all_or_distinct(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function With_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_with_clause; + return this; +} + +With_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +With_clauseContext.prototype.constructor = With_clauseContext; + +With_clauseContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +With_clauseContext.prototype.cte_list = function() { + return this.getTypedRuleContext(Cte_listContext,0); +}; + +With_clauseContext.prototype.RECURSIVE = function() { + return this.getToken(PostgreSQLParser.RECURSIVE, 0); +}; + +With_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterWith_clause(this); + } +}; + +With_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitWith_clause(this); + } +}; + +With_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitWith_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.With_clauseContext = With_clauseContext; + +PostgreSQLParser.prototype.with_clause = function() { + + var localctx = new With_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 966, PostgreSQLParser.RULE_with_clause); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7919; + this.match(PostgreSQLParser.WITH); + this.state = 7921; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,411,this._ctx); + if(la_===1) { + this.state = 7920; + this.match(PostgreSQLParser.RECURSIVE); + + } + this.state = 7923; + this.cte_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Cte_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_cte_list; + return this; +} + +Cte_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Cte_listContext.prototype.constructor = Cte_listContext; + +Cte_listContext.prototype.common_table_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Common_table_exprContext); + } else { + return this.getTypedRuleContext(Common_table_exprContext,i); + } +}; + +Cte_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Cte_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCte_list(this); + } +}; + +Cte_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCte_list(this); + } +}; + +Cte_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCte_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Cte_listContext = Cte_listContext; + +PostgreSQLParser.prototype.cte_list = function() { + + var localctx = new Cte_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 968, PostgreSQLParser.RULE_cte_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7925; + this.common_table_expr(); + this.state = 7930; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 7926; + this.match(PostgreSQLParser.COMMA); + this.state = 7927; + this.common_table_expr(); + this.state = 7932; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Common_table_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_common_table_expr; + return this; +} + +Common_table_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Common_table_exprContext.prototype.constructor = Common_table_exprContext; + +Common_table_exprContext.prototype.name = function() { + return this.getTypedRuleContext(NameContext,0); +}; + +Common_table_exprContext.prototype.opt_name_list = function() { + return this.getTypedRuleContext(Opt_name_listContext,0); +}; + +Common_table_exprContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Common_table_exprContext.prototype.opt_materialized = function() { + return this.getTypedRuleContext(Opt_materializedContext,0); +}; + +Common_table_exprContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Common_table_exprContext.prototype.preparablestmt = function() { + return this.getTypedRuleContext(PreparablestmtContext,0); +}; + +Common_table_exprContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Common_table_exprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCommon_table_expr(this); + } +}; + +Common_table_exprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCommon_table_expr(this); + } +}; + +Common_table_exprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCommon_table_expr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Common_table_exprContext = Common_table_exprContext; + +PostgreSQLParser.prototype.common_table_expr = function() { + + var localctx = new Common_table_exprContext(this, this._ctx, this.state); + this.enterRule(localctx, 970, PostgreSQLParser.RULE_common_table_expr); + try { + this.enterOuterAlt(localctx, 1); + this.state = 7933; + this.name(); + this.state = 7934; + this.opt_name_list(); + this.state = 7935; + this.match(PostgreSQLParser.AS); + this.state = 7936; + this.opt_materialized(); + this.state = 7937; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7938; + this.preparablestmt(); + this.state = 7939; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_materializedContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_materialized; + return this; +} + +Opt_materializedContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_materializedContext.prototype.constructor = Opt_materializedContext; + +Opt_materializedContext.prototype.MATERIALIZED = function() { + return this.getToken(PostgreSQLParser.MATERIALIZED, 0); +}; + +Opt_materializedContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +Opt_materializedContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_materialized(this); + } +}; + +Opt_materializedContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_materialized(this); + } +}; + +Opt_materializedContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_materialized(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_materializedContext = Opt_materializedContext; + +PostgreSQLParser.prototype.opt_materialized = function() { + + var localctx = new Opt_materializedContext(this, this._ctx, this.state); + this.enterRule(localctx, 972, PostgreSQLParser.RULE_opt_materialized); + try { + this.state = 7945; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.MATERIALIZED: + this.enterOuterAlt(localctx, 1); + this.state = 7941; + this.match(PostgreSQLParser.MATERIALIZED); + break; + case PostgreSQLParser.NOT: + this.enterOuterAlt(localctx, 2); + this.state = 7942; + this.match(PostgreSQLParser.NOT); + this.state = 7943; + this.match(PostgreSQLParser.MATERIALIZED); + break; + case PostgreSQLParser.OPEN_PAREN: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_with_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_with_clause; + return this; +} + +Opt_with_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_with_clauseContext.prototype.constructor = Opt_with_clauseContext; + +Opt_with_clauseContext.prototype.with_clause = function() { + return this.getTypedRuleContext(With_clauseContext,0); +}; + +Opt_with_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_with_clause(this); + } +}; + +Opt_with_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_with_clause(this); + } +}; + +Opt_with_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_with_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_with_clauseContext = Opt_with_clauseContext; + +PostgreSQLParser.prototype.opt_with_clause = function() { + + var localctx = new Opt_with_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 974, PostgreSQLParser.RULE_opt_with_clause); + try { + this.state = 7949; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.WITH: + this.enterOuterAlt(localctx, 1); + this.state = 7947; + this.with_clause(); + break; + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.UPDATE: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Into_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_into_clause; + return this; +} + +Into_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Into_clauseContext.prototype.constructor = Into_clauseContext; + +Into_clauseContext.prototype.INTO = function() { + return this.getToken(PostgreSQLParser.INTO, 0); +}; + +Into_clauseContext.prototype.opt_strict = function() { + return this.getTypedRuleContext(Opt_strictContext,0); +}; + +Into_clauseContext.prototype.opttempTableName = function() { + return this.getTypedRuleContext(OpttempTableNameContext,0); +}; + +Into_clauseContext.prototype.into_target = function() { + return this.getTypedRuleContext(Into_targetContext,0); +}; + +Into_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterInto_clause(this); + } +}; + +Into_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitInto_clause(this); + } +}; + +Into_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitInto_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Into_clauseContext = Into_clauseContext; + +PostgreSQLParser.prototype.into_clause = function() { + + var localctx = new Into_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 976, PostgreSQLParser.RULE_into_clause); + try { + this.state = 7959; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,416,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7951; + this.match(PostgreSQLParser.INTO); + this.state = 7956; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,415,this._ctx); + switch(la_) { + case 1: + this.state = 7952; + this.opt_strict(); + this.state = 7953; + this.opttempTableName(); + break; + + case 2: + this.state = 7955; + this.into_target(); + break; + + } + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_strictContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_strict; + return this; +} + +Opt_strictContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_strictContext.prototype.constructor = Opt_strictContext; + +Opt_strictContext.prototype.STRICT_P = function() { + return this.getToken(PostgreSQLParser.STRICT_P, 0); +}; + +Opt_strictContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_strict(this); + } +}; + +Opt_strictContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_strict(this); + } +}; + +Opt_strictContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_strict(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_strictContext = Opt_strictContext; + +PostgreSQLParser.prototype.opt_strict = function() { + + var localctx = new Opt_strictContext(this, this._ctx, this.state); + this.enterRule(localctx, 978, PostgreSQLParser.RULE_opt_strict); + try { + this.state = 7963; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,417,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7962; + this.match(PostgreSQLParser.STRICT_P); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OpttempTableNameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opttempTableName; + return this; +} + +OpttempTableNameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OpttempTableNameContext.prototype.constructor = OpttempTableNameContext; + +OpttempTableNameContext.prototype.opt_table = function() { + return this.getTypedRuleContext(Opt_tableContext,0); +}; + +OpttempTableNameContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +OpttempTableNameContext.prototype.TEMPORARY = function() { + return this.getToken(PostgreSQLParser.TEMPORARY, 0); +}; + +OpttempTableNameContext.prototype.TEMP = function() { + return this.getToken(PostgreSQLParser.TEMP, 0); +}; + +OpttempTableNameContext.prototype.LOCAL = function() { + return this.getToken(PostgreSQLParser.LOCAL, 0); +}; + +OpttempTableNameContext.prototype.GLOBAL = function() { + return this.getToken(PostgreSQLParser.GLOBAL, 0); +}; + +OpttempTableNameContext.prototype.UNLOGGED = function() { + return this.getToken(PostgreSQLParser.UNLOGGED, 0); +}; + +OpttempTableNameContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +OpttempTableNameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpttempTableName(this); + } +}; + +OpttempTableNameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpttempTableName(this); + } +}; + +OpttempTableNameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpttempTableName(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OpttempTableNameContext = OpttempTableNameContext; + +PostgreSQLParser.prototype.opttempTableName = function() { + + var localctx = new OpttempTableNameContext(this, this._ctx, this.state); + this.enterRule(localctx, 980, PostgreSQLParser.RULE_opttempTableName); + var _la = 0; // Token type + try { + this.state = 7979; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,419,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7966; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.GLOBAL || _la===PostgreSQLParser.LOCAL) { + this.state = 7965; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.GLOBAL || _la===PostgreSQLParser.LOCAL)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } + + this.state = 7968; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.TEMP || _la===PostgreSQLParser.TEMPORARY)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 7969; + this.opt_table(); + this.state = 7970; + this.qualified_name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 7972; + this.match(PostgreSQLParser.UNLOGGED); + this.state = 7973; + this.opt_table(); + this.state = 7974; + this.qualified_name(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 7976; + this.match(PostgreSQLParser.TABLE); + this.state = 7977; + this.qualified_name(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 7978; + this.qualified_name(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_tableContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_table; + return this; +} + +Opt_tableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_tableContext.prototype.constructor = Opt_tableContext; + +Opt_tableContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +Opt_tableContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_table(this); + } +}; + +Opt_tableContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_table(this); + } +}; + +Opt_tableContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_table(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_tableContext = Opt_tableContext; + +PostgreSQLParser.prototype.opt_table = function() { + + var localctx = new Opt_tableContext(this, this._ctx, this.state); + this.enterRule(localctx, 982, PostgreSQLParser.RULE_opt_table); + try { + this.state = 7983; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,420,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 7981; + this.match(PostgreSQLParser.TABLE); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function All_or_distinctContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_all_or_distinct; + return this; +} + +All_or_distinctContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +All_or_distinctContext.prototype.constructor = All_or_distinctContext; + +All_or_distinctContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +All_or_distinctContext.prototype.DISTINCT = function() { + return this.getToken(PostgreSQLParser.DISTINCT, 0); +}; + +All_or_distinctContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAll_or_distinct(this); + } +}; + +All_or_distinctContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAll_or_distinct(this); + } +}; + +All_or_distinctContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAll_or_distinct(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.All_or_distinctContext = All_or_distinctContext; + +PostgreSQLParser.prototype.all_or_distinct = function() { + + var localctx = new All_or_distinctContext(this, this._ctx, this.state); + this.enterRule(localctx, 984, PostgreSQLParser.RULE_all_or_distinct); + try { + this.state = 7988; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ALL: + this.enterOuterAlt(localctx, 1); + this.state = 7985; + this.match(PostgreSQLParser.ALL); + break; + case PostgreSQLParser.DISTINCT: + this.enterOuterAlt(localctx, 2); + this.state = 7986; + this.match(PostgreSQLParser.DISTINCT); + break; + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.VALUES: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Distinct_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_distinct_clause; + return this; +} + +Distinct_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Distinct_clauseContext.prototype.constructor = Distinct_clauseContext; + +Distinct_clauseContext.prototype.DISTINCT = function() { + return this.getToken(PostgreSQLParser.DISTINCT, 0); +}; + +Distinct_clauseContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +Distinct_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Distinct_clauseContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Distinct_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Distinct_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDistinct_clause(this); + } +}; + +Distinct_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDistinct_clause(this); + } +}; + +Distinct_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDistinct_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Distinct_clauseContext = Distinct_clauseContext; + +PostgreSQLParser.prototype.distinct_clause = function() { + + var localctx = new Distinct_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 986, PostgreSQLParser.RULE_distinct_clause); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 7990; + this.match(PostgreSQLParser.DISTINCT); + this.state = 7996; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.ON) { + this.state = 7991; + this.match(PostgreSQLParser.ON); + this.state = 7992; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 7993; + this.expr_list(); + this.state = 7994; + this.match(PostgreSQLParser.CLOSE_PAREN); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_all_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_all_clause; + return this; +} + +Opt_all_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_all_clauseContext.prototype.constructor = Opt_all_clauseContext; + +Opt_all_clauseContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Opt_all_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_all_clause(this); + } +}; + +Opt_all_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_all_clause(this); + } +}; + +Opt_all_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_all_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_all_clauseContext = Opt_all_clauseContext; + +PostgreSQLParser.prototype.opt_all_clause = function() { + + var localctx = new Opt_all_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 988, PostgreSQLParser.RULE_opt_all_clause); + try { + this.state = 8000; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ALL: + this.enterOuterAlt(localctx, 1); + this.state = 7998; + this.match(PostgreSQLParser.ALL); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.STAR: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.Operator: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.FROM: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.GROUP_P: + case PostgreSQLParser.HAVING: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNION: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.MetaCommand: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_sort_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_sort_clause; + return this; +} + +Opt_sort_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_sort_clauseContext.prototype.constructor = Opt_sort_clauseContext; + +Opt_sort_clauseContext.prototype.sort_clause = function() { + return this.getTypedRuleContext(Sort_clauseContext,0); +}; + +Opt_sort_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_sort_clause(this); + } +}; + +Opt_sort_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_sort_clause(this); + } +}; + +Opt_sort_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_sort_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_sort_clauseContext = Opt_sort_clauseContext; + +PostgreSQLParser.prototype.opt_sort_clause = function() { + + var localctx = new Opt_sort_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 990, PostgreSQLParser.RULE_opt_sort_clause); + try { + this.state = 8004; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ORDER: + this.enterOuterAlt(localctx, 1); + this.state = 8002; + this.sort_clause(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Sort_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_sort_clause; + return this; +} + +Sort_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Sort_clauseContext.prototype.constructor = Sort_clauseContext; + +Sort_clauseContext.prototype.ORDER = function() { + return this.getToken(PostgreSQLParser.ORDER, 0); +}; + +Sort_clauseContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Sort_clauseContext.prototype.sortby_list = function() { + return this.getTypedRuleContext(Sortby_listContext,0); +}; + +Sort_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSort_clause(this); + } +}; + +Sort_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSort_clause(this); + } +}; + +Sort_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSort_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Sort_clauseContext = Sort_clauseContext; + +PostgreSQLParser.prototype.sort_clause = function() { + + var localctx = new Sort_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 992, PostgreSQLParser.RULE_sort_clause); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8006; + this.match(PostgreSQLParser.ORDER); + this.state = 8007; + this.match(PostgreSQLParser.BY); + this.state = 8008; + this.sortby_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Sortby_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_sortby_list; + return this; +} + +Sortby_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Sortby_listContext.prototype.constructor = Sortby_listContext; + +Sortby_listContext.prototype.sortby = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(SortbyContext); + } else { + return this.getTypedRuleContext(SortbyContext,i); + } +}; + +Sortby_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Sortby_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSortby_list(this); + } +}; + +Sortby_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSortby_list(this); + } +}; + +Sortby_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSortby_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Sortby_listContext = Sortby_listContext; + +PostgreSQLParser.prototype.sortby_list = function() { + + var localctx = new Sortby_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 994, PostgreSQLParser.RULE_sortby_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8010; + this.sortby(); + this.state = 8015; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 8011; + this.match(PostgreSQLParser.COMMA); + this.state = 8012; + this.sortby(); + this.state = 8017; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function SortbyContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_sortby; + return this; +} + +SortbyContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +SortbyContext.prototype.constructor = SortbyContext; + +SortbyContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +SortbyContext.prototype.opt_nulls_order = function() { + return this.getTypedRuleContext(Opt_nulls_orderContext,0); +}; + +SortbyContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +SortbyContext.prototype.qual_all_op = function() { + return this.getTypedRuleContext(Qual_all_opContext,0); +}; + +SortbyContext.prototype.opt_asc_desc = function() { + return this.getTypedRuleContext(Opt_asc_descContext,0); +}; + +SortbyContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSortby(this); + } +}; + +SortbyContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSortby(this); + } +}; + +SortbyContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSortby(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.SortbyContext = SortbyContext; + +PostgreSQLParser.prototype.sortby = function() { + + var localctx = new SortbyContext(this, this._ctx, this.state); + this.enterRule(localctx, 996, PostgreSQLParser.RULE_sortby); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8018; + this.a_expr(); + this.state = 8022; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + this.state = 8019; + this.match(PostgreSQLParser.USING); + this.state = 8020; + this.qual_all_op(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.ASC: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DESC: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.state = 8021; + this.opt_asc_desc(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 8024; + this.opt_nulls_order(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Select_limitContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_select_limit; + return this; +} + +Select_limitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Select_limitContext.prototype.constructor = Select_limitContext; + +Select_limitContext.prototype.limit_clause = function() { + return this.getTypedRuleContext(Limit_clauseContext,0); +}; + +Select_limitContext.prototype.offset_clause = function() { + return this.getTypedRuleContext(Offset_clauseContext,0); +}; + +Select_limitContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSelect_limit(this); + } +}; + +Select_limitContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSelect_limit(this); + } +}; + +Select_limitContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSelect_limit(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Select_limitContext = Select_limitContext; + +PostgreSQLParser.prototype.select_limit = function() { + + var localctx = new Select_limitContext(this, this._ctx, this.state); + this.enterRule(localctx, 998, PostgreSQLParser.RULE_select_limit); + var _la = 0; // Token type + try { + this.state = 8034; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FETCH: + case PostgreSQLParser.LIMIT: + this.enterOuterAlt(localctx, 1); + this.state = 8026; + this.limit_clause(); + this.state = 8028; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OFFSET) { + this.state = 8027; + this.offset_clause(); + } + + break; + case PostgreSQLParser.OFFSET: + this.enterOuterAlt(localctx, 2); + this.state = 8030; + this.offset_clause(); + this.state = 8032; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,428,this._ctx); + if(la_===1) { + this.state = 8031; + this.limit_clause(); + + } + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_select_limitContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_select_limit; + return this; +} + +Opt_select_limitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_select_limitContext.prototype.constructor = Opt_select_limitContext; + +Opt_select_limitContext.prototype.select_limit = function() { + return this.getTypedRuleContext(Select_limitContext,0); +}; + +Opt_select_limitContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_select_limit(this); + } +}; + +Opt_select_limitContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_select_limit(this); + } +}; + +Opt_select_limitContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_select_limit(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_select_limitContext = Opt_select_limitContext; + +PostgreSQLParser.prototype.opt_select_limit = function() { + + var localctx = new Opt_select_limitContext(this, this._ctx, this.state); + this.enterRule(localctx, 1000, PostgreSQLParser.RULE_opt_select_limit); + try { + this.state = 8038; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,430,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8036; + this.select_limit(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Limit_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_limit_clause; + return this; +} + +Limit_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Limit_clauseContext.prototype.constructor = Limit_clauseContext; + +Limit_clauseContext.prototype.LIMIT = function() { + return this.getToken(PostgreSQLParser.LIMIT, 0); +}; + +Limit_clauseContext.prototype.select_limit_value = function() { + return this.getTypedRuleContext(Select_limit_valueContext,0); +}; + +Limit_clauseContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +Limit_clauseContext.prototype.select_offset_value = function() { + return this.getTypedRuleContext(Select_offset_valueContext,0); +}; + +Limit_clauseContext.prototype.FETCH = function() { + return this.getToken(PostgreSQLParser.FETCH, 0); +}; + +Limit_clauseContext.prototype.first_or_next = function() { + return this.getTypedRuleContext(First_or_nextContext,0); +}; + +Limit_clauseContext.prototype.select_fetch_first_value = function() { + return this.getTypedRuleContext(Select_fetch_first_valueContext,0); +}; + +Limit_clauseContext.prototype.row_or_rows = function() { + return this.getTypedRuleContext(Row_or_rowsContext,0); +}; + +Limit_clauseContext.prototype.ONLY = function() { + return this.getToken(PostgreSQLParser.ONLY, 0); +}; + +Limit_clauseContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Limit_clauseContext.prototype.TIES = function() { + return this.getToken(PostgreSQLParser.TIES, 0); +}; + +Limit_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterLimit_clause(this); + } +}; + +Limit_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitLimit_clause(this); + } +}; + +Limit_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitLimit_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Limit_clauseContext = Limit_clauseContext; + +PostgreSQLParser.prototype.limit_clause = function() { + + var localctx = new Limit_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1002, PostgreSQLParser.RULE_limit_clause); + var _la = 0; // Token type + try { + this.state = 8063; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.LIMIT: + this.enterOuterAlt(localctx, 1); + this.state = 8040; + this.match(PostgreSQLParser.LIMIT); + this.state = 8041; + this.select_limit_value(); + this.state = 8044; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.COMMA) { + this.state = 8042; + this.match(PostgreSQLParser.COMMA); + this.state = 8043; + this.select_offset_value(); + } + + break; + case PostgreSQLParser.FETCH: + this.enterOuterAlt(localctx, 2); + this.state = 8046; + this.match(PostgreSQLParser.FETCH); + this.state = 8047; + this.first_or_next(); + this.state = 8061; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,434,this._ctx); + switch(la_) { + case 1: + this.state = 8048; + this.select_fetch_first_value(); + this.state = 8049; + this.row_or_rows(); + this.state = 8053; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ONLY: + this.state = 8050; + this.match(PostgreSQLParser.ONLY); + break; + case PostgreSQLParser.WITH: + this.state = 8051; + this.match(PostgreSQLParser.WITH); + this.state = 8052; + this.match(PostgreSQLParser.TIES); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 2: + this.state = 8055; + this.row_or_rows(); + this.state = 8059; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ONLY: + this.state = 8056; + this.match(PostgreSQLParser.ONLY); + break; + case PostgreSQLParser.WITH: + this.state = 8057; + this.match(PostgreSQLParser.WITH); + this.state = 8058; + this.match(PostgreSQLParser.TIES); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + } + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Offset_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_offset_clause; + return this; +} + +Offset_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Offset_clauseContext.prototype.constructor = Offset_clauseContext; + +Offset_clauseContext.prototype.OFFSET = function() { + return this.getToken(PostgreSQLParser.OFFSET, 0); +}; + +Offset_clauseContext.prototype.select_offset_value = function() { + return this.getTypedRuleContext(Select_offset_valueContext,0); +}; + +Offset_clauseContext.prototype.select_fetch_first_value = function() { + return this.getTypedRuleContext(Select_fetch_first_valueContext,0); +}; + +Offset_clauseContext.prototype.row_or_rows = function() { + return this.getTypedRuleContext(Row_or_rowsContext,0); +}; + +Offset_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOffset_clause(this); + } +}; + +Offset_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOffset_clause(this); + } +}; + +Offset_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOffset_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Offset_clauseContext = Offset_clauseContext; + +PostgreSQLParser.prototype.offset_clause = function() { + + var localctx = new Offset_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1004, PostgreSQLParser.RULE_offset_clause); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8065; + this.match(PostgreSQLParser.OFFSET); + this.state = 8070; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,436,this._ctx); + switch(la_) { + case 1: + this.state = 8066; + this.select_offset_value(); + break; + + case 2: + this.state = 8067; + this.select_fetch_first_value(); + this.state = 8068; + this.row_or_rows(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Select_limit_valueContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_select_limit_value; + return this; +} + +Select_limit_valueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Select_limit_valueContext.prototype.constructor = Select_limit_valueContext; + +Select_limit_valueContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Select_limit_valueContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Select_limit_valueContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSelect_limit_value(this); + } +}; + +Select_limit_valueContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSelect_limit_value(this); + } +}; + +Select_limit_valueContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSelect_limit_value(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Select_limit_valueContext = Select_limit_valueContext; + +PostgreSQLParser.prototype.select_limit_value = function() { + + var localctx = new Select_limit_valueContext(this, this._ctx, this.state); + this.enterRule(localctx, 1006, PostgreSQLParser.RULE_select_limit_value); + try { + this.state = 8074; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.Operator: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 8072; + this.a_expr(); + break; + case PostgreSQLParser.ALL: + this.enterOuterAlt(localctx, 2); + this.state = 8073; + this.match(PostgreSQLParser.ALL); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Select_offset_valueContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_select_offset_value; + return this; +} + +Select_offset_valueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Select_offset_valueContext.prototype.constructor = Select_offset_valueContext; + +Select_offset_valueContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Select_offset_valueContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSelect_offset_value(this); + } +}; + +Select_offset_valueContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSelect_offset_value(this); + } +}; + +Select_offset_valueContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSelect_offset_value(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Select_offset_valueContext = Select_offset_valueContext; + +PostgreSQLParser.prototype.select_offset_value = function() { + + var localctx = new Select_offset_valueContext(this, this._ctx, this.state); + this.enterRule(localctx, 1008, PostgreSQLParser.RULE_select_offset_value); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8076; + this.a_expr(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Select_fetch_first_valueContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_select_fetch_first_value; + return this; +} + +Select_fetch_first_valueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Select_fetch_first_valueContext.prototype.constructor = Select_fetch_first_valueContext; + +Select_fetch_first_valueContext.prototype.c_expr = function() { + return this.getTypedRuleContext(C_exprContext,0); +}; + +Select_fetch_first_valueContext.prototype.PLUS = function() { + return this.getToken(PostgreSQLParser.PLUS, 0); +}; + +Select_fetch_first_valueContext.prototype.i_or_f_const = function() { + return this.getTypedRuleContext(I_or_f_constContext,0); +}; + +Select_fetch_first_valueContext.prototype.MINUS = function() { + return this.getToken(PostgreSQLParser.MINUS, 0); +}; + +Select_fetch_first_valueContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSelect_fetch_first_value(this); + } +}; + +Select_fetch_first_valueContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSelect_fetch_first_value(this); + } +}; + +Select_fetch_first_valueContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSelect_fetch_first_value(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Select_fetch_first_valueContext = Select_fetch_first_valueContext; + +PostgreSQLParser.prototype.select_fetch_first_value = function() { + + var localctx = new Select_fetch_first_valueContext(this, this._ctx, this.state); + this.enterRule(localctx, 1010, PostgreSQLParser.RULE_select_fetch_first_value); + try { + this.state = 8083; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 8078; + this.c_expr(); + break; + case PostgreSQLParser.PLUS: + this.enterOuterAlt(localctx, 2); + this.state = 8079; + this.match(PostgreSQLParser.PLUS); + this.state = 8080; + this.i_or_f_const(); + break; + case PostgreSQLParser.MINUS: + this.enterOuterAlt(localctx, 3); + this.state = 8081; + this.match(PostgreSQLParser.MINUS); + this.state = 8082; + this.i_or_f_const(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function I_or_f_constContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_i_or_f_const; + return this; +} + +I_or_f_constContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +I_or_f_constContext.prototype.constructor = I_or_f_constContext; + +I_or_f_constContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +I_or_f_constContext.prototype.fconst = function() { + return this.getTypedRuleContext(FconstContext,0); +}; + +I_or_f_constContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterI_or_f_const(this); + } +}; + +I_or_f_constContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitI_or_f_const(this); + } +}; + +I_or_f_constContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitI_or_f_const(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.I_or_f_constContext = I_or_f_constContext; + +PostgreSQLParser.prototype.i_or_f_const = function() { + + var localctx = new I_or_f_constContext(this, this._ctx, this.state); + this.enterRule(localctx, 1012, PostgreSQLParser.RULE_i_or_f_const); + try { + this.state = 8087; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.Integral: + this.enterOuterAlt(localctx, 1); + this.state = 8085; + this.iconst(); + break; + case PostgreSQLParser.Numeric: + this.enterOuterAlt(localctx, 2); + this.state = 8086; + this.fconst(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Row_or_rowsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_row_or_rows; + return this; +} + +Row_or_rowsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Row_or_rowsContext.prototype.constructor = Row_or_rowsContext; + +Row_or_rowsContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +Row_or_rowsContext.prototype.ROWS = function() { + return this.getToken(PostgreSQLParser.ROWS, 0); +}; + +Row_or_rowsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRow_or_rows(this); + } +}; + +Row_or_rowsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRow_or_rows(this); + } +}; + +Row_or_rowsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRow_or_rows(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Row_or_rowsContext = Row_or_rowsContext; + +PostgreSQLParser.prototype.row_or_rows = function() { + + var localctx = new Row_or_rowsContext(this, this._ctx, this.state); + this.enterRule(localctx, 1014, PostgreSQLParser.RULE_row_or_rows); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8089; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.ROWS || _la===PostgreSQLParser.ROW)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function First_or_nextContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_first_or_next; + return this; +} + +First_or_nextContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +First_or_nextContext.prototype.constructor = First_or_nextContext; + +First_or_nextContext.prototype.FIRST_P = function() { + return this.getToken(PostgreSQLParser.FIRST_P, 0); +}; + +First_or_nextContext.prototype.NEXT = function() { + return this.getToken(PostgreSQLParser.NEXT, 0); +}; + +First_or_nextContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFirst_or_next(this); + } +}; + +First_or_nextContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFirst_or_next(this); + } +}; + +First_or_nextContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFirst_or_next(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.First_or_nextContext = First_or_nextContext; + +PostgreSQLParser.prototype.first_or_next = function() { + + var localctx = new First_or_nextContext(this, this._ctx, this.state); + this.enterRule(localctx, 1016, PostgreSQLParser.RULE_first_or_next); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8091; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FIRST_P || _la===PostgreSQLParser.NEXT)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Group_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_group_clause; + return this; +} + +Group_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Group_clauseContext.prototype.constructor = Group_clauseContext; + +Group_clauseContext.prototype.GROUP_P = function() { + return this.getToken(PostgreSQLParser.GROUP_P, 0); +}; + +Group_clauseContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Group_clauseContext.prototype.group_by_list = function() { + return this.getTypedRuleContext(Group_by_listContext,0); +}; + +Group_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGroup_clause(this); + } +}; + +Group_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGroup_clause(this); + } +}; + +Group_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGroup_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Group_clauseContext = Group_clauseContext; + +PostgreSQLParser.prototype.group_clause = function() { + + var localctx = new Group_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1018, PostgreSQLParser.RULE_group_clause); + try { + this.state = 8097; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.GROUP_P: + this.enterOuterAlt(localctx, 1); + this.state = 8093; + this.match(PostgreSQLParser.GROUP_P); + this.state = 8094; + this.match(PostgreSQLParser.BY); + this.state = 8095; + this.group_by_list(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.HAVING: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.THEN: + case PostgreSQLParser.UNION: + case PostgreSQLParser.USING: + case PostgreSQLParser.WHEN: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Group_by_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_group_by_list; + return this; +} + +Group_by_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Group_by_listContext.prototype.constructor = Group_by_listContext; + +Group_by_listContext.prototype.group_by_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Group_by_itemContext); + } else { + return this.getTypedRuleContext(Group_by_itemContext,i); + } +}; + +Group_by_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Group_by_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGroup_by_list(this); + } +}; + +Group_by_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGroup_by_list(this); + } +}; + +Group_by_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGroup_by_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Group_by_listContext = Group_by_listContext; + +PostgreSQLParser.prototype.group_by_list = function() { + + var localctx = new Group_by_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1020, PostgreSQLParser.RULE_group_by_list); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8099; + this.group_by_item(); + this.state = 8104; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,441,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 8100; + this.match(PostgreSQLParser.COMMA); + this.state = 8101; + this.group_by_item(); + } + this.state = 8106; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,441,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Group_by_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_group_by_item; + return this; +} + +Group_by_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Group_by_itemContext.prototype.constructor = Group_by_itemContext; + +Group_by_itemContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Group_by_itemContext.prototype.empty_grouping_set = function() { + return this.getTypedRuleContext(Empty_grouping_setContext,0); +}; + +Group_by_itemContext.prototype.cube_clause = function() { + return this.getTypedRuleContext(Cube_clauseContext,0); +}; + +Group_by_itemContext.prototype.rollup_clause = function() { + return this.getTypedRuleContext(Rollup_clauseContext,0); +}; + +Group_by_itemContext.prototype.grouping_sets_clause = function() { + return this.getTypedRuleContext(Grouping_sets_clauseContext,0); +}; + +Group_by_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGroup_by_item(this); + } +}; + +Group_by_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGroup_by_item(this); + } +}; + +Group_by_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGroup_by_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Group_by_itemContext = Group_by_itemContext; + +PostgreSQLParser.prototype.group_by_item = function() { + + var localctx = new Group_by_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 1022, PostgreSQLParser.RULE_group_by_item); + try { + this.state = 8112; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,442,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8107; + this.a_expr(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8108; + this.empty_grouping_set(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 8109; + this.cube_clause(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 8110; + this.rollup_clause(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 8111; + this.grouping_sets_clause(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Empty_grouping_setContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_empty_grouping_set; + return this; +} + +Empty_grouping_setContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Empty_grouping_setContext.prototype.constructor = Empty_grouping_setContext; + +Empty_grouping_setContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Empty_grouping_setContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Empty_grouping_setContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterEmpty_grouping_set(this); + } +}; + +Empty_grouping_setContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitEmpty_grouping_set(this); + } +}; + +Empty_grouping_setContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitEmpty_grouping_set(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Empty_grouping_setContext = Empty_grouping_setContext; + +PostgreSQLParser.prototype.empty_grouping_set = function() { + + var localctx = new Empty_grouping_setContext(this, this._ctx, this.state); + this.enterRule(localctx, 1024, PostgreSQLParser.RULE_empty_grouping_set); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8114; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8115; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Rollup_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rollup_clause; + return this; +} + +Rollup_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Rollup_clauseContext.prototype.constructor = Rollup_clauseContext; + +Rollup_clauseContext.prototype.ROLLUP = function() { + return this.getToken(PostgreSQLParser.ROLLUP, 0); +}; + +Rollup_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Rollup_clauseContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Rollup_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Rollup_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRollup_clause(this); + } +}; + +Rollup_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRollup_clause(this); + } +}; + +Rollup_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRollup_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Rollup_clauseContext = Rollup_clauseContext; + +PostgreSQLParser.prototype.rollup_clause = function() { + + var localctx = new Rollup_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1026, PostgreSQLParser.RULE_rollup_clause); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8117; + this.match(PostgreSQLParser.ROLLUP); + this.state = 8118; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8119; + this.expr_list(); + this.state = 8120; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Cube_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_cube_clause; + return this; +} + +Cube_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Cube_clauseContext.prototype.constructor = Cube_clauseContext; + +Cube_clauseContext.prototype.CUBE = function() { + return this.getToken(PostgreSQLParser.CUBE, 0); +}; + +Cube_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Cube_clauseContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Cube_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Cube_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCube_clause(this); + } +}; + +Cube_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCube_clause(this); + } +}; + +Cube_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCube_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Cube_clauseContext = Cube_clauseContext; + +PostgreSQLParser.prototype.cube_clause = function() { + + var localctx = new Cube_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1028, PostgreSQLParser.RULE_cube_clause); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8122; + this.match(PostgreSQLParser.CUBE); + this.state = 8123; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8124; + this.expr_list(); + this.state = 8125; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Grouping_sets_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_grouping_sets_clause; + return this; +} + +Grouping_sets_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Grouping_sets_clauseContext.prototype.constructor = Grouping_sets_clauseContext; + +Grouping_sets_clauseContext.prototype.GROUPING = function() { + return this.getToken(PostgreSQLParser.GROUPING, 0); +}; + +Grouping_sets_clauseContext.prototype.SETS = function() { + return this.getToken(PostgreSQLParser.SETS, 0); +}; + +Grouping_sets_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Grouping_sets_clauseContext.prototype.group_by_list = function() { + return this.getTypedRuleContext(Group_by_listContext,0); +}; + +Grouping_sets_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Grouping_sets_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGrouping_sets_clause(this); + } +}; + +Grouping_sets_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGrouping_sets_clause(this); + } +}; + +Grouping_sets_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGrouping_sets_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Grouping_sets_clauseContext = Grouping_sets_clauseContext; + +PostgreSQLParser.prototype.grouping_sets_clause = function() { + + var localctx = new Grouping_sets_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1030, PostgreSQLParser.RULE_grouping_sets_clause); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8127; + this.match(PostgreSQLParser.GROUPING); + this.state = 8128; + this.match(PostgreSQLParser.SETS); + this.state = 8129; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8130; + this.group_by_list(); + this.state = 8131; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Having_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_having_clause; + return this; +} + +Having_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Having_clauseContext.prototype.constructor = Having_clauseContext; + +Having_clauseContext.prototype.HAVING = function() { + return this.getToken(PostgreSQLParser.HAVING, 0); +}; + +Having_clauseContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Having_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterHaving_clause(this); + } +}; + +Having_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitHaving_clause(this); + } +}; + +Having_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitHaving_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Having_clauseContext = Having_clauseContext; + +PostgreSQLParser.prototype.having_clause = function() { + + var localctx = new Having_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1032, PostgreSQLParser.RULE_having_clause); + try { + this.state = 8136; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.HAVING: + this.enterOuterAlt(localctx, 1); + this.state = 8133; + this.match(PostgreSQLParser.HAVING); + this.state = 8134; + this.a_expr(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.THEN: + case PostgreSQLParser.UNION: + case PostgreSQLParser.USING: + case PostgreSQLParser.WHEN: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function For_locking_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_for_locking_clause; + return this; +} + +For_locking_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +For_locking_clauseContext.prototype.constructor = For_locking_clauseContext; + +For_locking_clauseContext.prototype.for_locking_items = function() { + return this.getTypedRuleContext(For_locking_itemsContext,0); +}; + +For_locking_clauseContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +For_locking_clauseContext.prototype.READ = function() { + return this.getToken(PostgreSQLParser.READ, 0); +}; + +For_locking_clauseContext.prototype.ONLY = function() { + return this.getToken(PostgreSQLParser.ONLY, 0); +}; + +For_locking_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFor_locking_clause(this); + } +}; + +For_locking_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFor_locking_clause(this); + } +}; + +For_locking_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFor_locking_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.For_locking_clauseContext = For_locking_clauseContext; + +PostgreSQLParser.prototype.for_locking_clause = function() { + + var localctx = new For_locking_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1034, PostgreSQLParser.RULE_for_locking_clause); + try { + this.state = 8142; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,444,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8138; + this.for_locking_items(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8139; + this.match(PostgreSQLParser.FOR); + this.state = 8140; + this.match(PostgreSQLParser.READ); + this.state = 8141; + this.match(PostgreSQLParser.ONLY); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_for_locking_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_for_locking_clause; + return this; +} + +Opt_for_locking_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_for_locking_clauseContext.prototype.constructor = Opt_for_locking_clauseContext; + +Opt_for_locking_clauseContext.prototype.for_locking_clause = function() { + return this.getTypedRuleContext(For_locking_clauseContext,0); +}; + +Opt_for_locking_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_for_locking_clause(this); + } +}; + +Opt_for_locking_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_for_locking_clause(this); + } +}; + +Opt_for_locking_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_for_locking_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_for_locking_clauseContext = Opt_for_locking_clauseContext; + +PostgreSQLParser.prototype.opt_for_locking_clause = function() { + + var localctx = new Opt_for_locking_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1036, PostgreSQLParser.RULE_opt_for_locking_clause); + try { + this.state = 8146; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FOR: + this.enterOuterAlt(localctx, 1); + this.state = 8144; + this.for_locking_clause(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.ON: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function For_locking_itemsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_for_locking_items; + return this; +} + +For_locking_itemsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +For_locking_itemsContext.prototype.constructor = For_locking_itemsContext; + +For_locking_itemsContext.prototype.for_locking_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(For_locking_itemContext); + } else { + return this.getTypedRuleContext(For_locking_itemContext,i); + } +}; + +For_locking_itemsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFor_locking_items(this); + } +}; + +For_locking_itemsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFor_locking_items(this); + } +}; + +For_locking_itemsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFor_locking_items(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.For_locking_itemsContext = For_locking_itemsContext; + +PostgreSQLParser.prototype.for_locking_items = function() { + + var localctx = new For_locking_itemsContext(this, this._ctx, this.state); + this.enterRule(localctx, 1038, PostgreSQLParser.RULE_for_locking_items); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8149; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + this.state = 8148; + this.for_locking_item(); + this.state = 8151; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while(_la===PostgreSQLParser.FOR); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function For_locking_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_for_locking_item; + return this; +} + +For_locking_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +For_locking_itemContext.prototype.constructor = For_locking_itemContext; + +For_locking_itemContext.prototype.for_locking_strength = function() { + return this.getTypedRuleContext(For_locking_strengthContext,0); +}; + +For_locking_itemContext.prototype.locked_rels_list = function() { + return this.getTypedRuleContext(Locked_rels_listContext,0); +}; + +For_locking_itemContext.prototype.opt_nowait_or_skip = function() { + return this.getTypedRuleContext(Opt_nowait_or_skipContext,0); +}; + +For_locking_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFor_locking_item(this); + } +}; + +For_locking_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFor_locking_item(this); + } +}; + +For_locking_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFor_locking_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.For_locking_itemContext = For_locking_itemContext; + +PostgreSQLParser.prototype.for_locking_item = function() { + + var localctx = new For_locking_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 1040, PostgreSQLParser.RULE_for_locking_item); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8153; + this.for_locking_strength(); + this.state = 8154; + this.locked_rels_list(); + this.state = 8155; + this.opt_nowait_or_skip(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function For_locking_strengthContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_for_locking_strength; + return this; +} + +For_locking_strengthContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +For_locking_strengthContext.prototype.constructor = For_locking_strengthContext; + +For_locking_strengthContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +For_locking_strengthContext.prototype.UPDATE = function() { + return this.getToken(PostgreSQLParser.UPDATE, 0); +}; + +For_locking_strengthContext.prototype.SHARE = function() { + return this.getToken(PostgreSQLParser.SHARE, 0); +}; + +For_locking_strengthContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +For_locking_strengthContext.prototype.KEY = function() { + return this.getToken(PostgreSQLParser.KEY, 0); +}; + +For_locking_strengthContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFor_locking_strength(this); + } +}; + +For_locking_strengthContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFor_locking_strength(this); + } +}; + +For_locking_strengthContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFor_locking_strength(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.For_locking_strengthContext = For_locking_strengthContext; + +PostgreSQLParser.prototype.for_locking_strength = function() { + + var localctx = new For_locking_strengthContext(this, this._ctx, this.state); + this.enterRule(localctx, 1042, PostgreSQLParser.RULE_for_locking_strength); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8157; + this.match(PostgreSQLParser.FOR); + this.state = 8167; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NO: + case PostgreSQLParser.UPDATE: + this.state = 8160; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.NO) { + this.state = 8158; + this.match(PostgreSQLParser.NO); + this.state = 8159; + this.match(PostgreSQLParser.KEY); + } + + this.state = 8162; + this.match(PostgreSQLParser.UPDATE); + break; + case PostgreSQLParser.KEY: + case PostgreSQLParser.SHARE: + this.state = 8164; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.KEY) { + this.state = 8163; + this.match(PostgreSQLParser.KEY); + } + + this.state = 8166; + this.match(PostgreSQLParser.SHARE); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Locked_rels_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_locked_rels_list; + return this; +} + +Locked_rels_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Locked_rels_listContext.prototype.constructor = Locked_rels_listContext; + +Locked_rels_listContext.prototype.OF = function() { + return this.getToken(PostgreSQLParser.OF, 0); +}; + +Locked_rels_listContext.prototype.qualified_name_list = function() { + return this.getTypedRuleContext(Qualified_name_listContext,0); +}; + +Locked_rels_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterLocked_rels_list(this); + } +}; + +Locked_rels_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitLocked_rels_list(this); + } +}; + +Locked_rels_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitLocked_rels_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Locked_rels_listContext = Locked_rels_listContext; + +PostgreSQLParser.prototype.locked_rels_list = function() { + + var localctx = new Locked_rels_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1044, PostgreSQLParser.RULE_locked_rels_list); + try { + this.state = 8172; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OF: + this.enterOuterAlt(localctx, 1); + this.state = 8169; + this.match(PostgreSQLParser.OF); + this.state = 8170; + this.qualified_name_list(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Values_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_values_clause; + return this; +} + +Values_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Values_clauseContext.prototype.constructor = Values_clauseContext; + +Values_clauseContext.prototype.VALUES = function() { + return this.getToken(PostgreSQLParser.VALUES, 0); +}; + +Values_clauseContext.prototype.OPEN_PAREN = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.OPEN_PAREN); + } else { + return this.getToken(PostgreSQLParser.OPEN_PAREN, i); + } +}; + + +Values_clauseContext.prototype.expr_list = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Expr_listContext); + } else { + return this.getTypedRuleContext(Expr_listContext,i); + } +}; + +Values_clauseContext.prototype.CLOSE_PAREN = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.CLOSE_PAREN); + } else { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, i); + } +}; + + +Values_clauseContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Values_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterValues_clause(this); + } +}; + +Values_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitValues_clause(this); + } +}; + +Values_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitValues_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Values_clauseContext = Values_clauseContext; + +PostgreSQLParser.prototype.values_clause = function() { + + var localctx = new Values_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1046, PostgreSQLParser.RULE_values_clause); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8174; + this.match(PostgreSQLParser.VALUES); + this.state = 8175; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8176; + this.expr_list(); + this.state = 8177; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 8185; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 8178; + this.match(PostgreSQLParser.COMMA); + this.state = 8179; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8180; + this.expr_list(); + this.state = 8181; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 8187; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function From_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_from_clause; + return this; +} + +From_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +From_clauseContext.prototype.constructor = From_clauseContext; + +From_clauseContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +From_clauseContext.prototype.from_list = function() { + return this.getTypedRuleContext(From_listContext,0); +}; + +From_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFrom_clause(this); + } +}; + +From_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFrom_clause(this); + } +}; + +From_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFrom_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.From_clauseContext = From_clauseContext; + +PostgreSQLParser.prototype.from_clause = function() { + + var localctx = new From_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1048, PostgreSQLParser.RULE_from_clause); + try { + this.state = 8191; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FROM: + this.enterOuterAlt(localctx, 1); + this.state = 8188; + this.match(PostgreSQLParser.FROM); + this.state = 8189; + this.from_list(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.GROUP_P: + case PostgreSQLParser.HAVING: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.THEN: + case PostgreSQLParser.UNION: + case PostgreSQLParser.USING: + case PostgreSQLParser.WHEN: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function From_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_from_list; + return this; +} + +From_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +From_listContext.prototype.constructor = From_listContext; + +From_listContext.prototype.table_ref = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Table_refContext); + } else { + return this.getTypedRuleContext(Table_refContext,i); + } +}; + +From_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +From_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFrom_list(this); + } +}; + +From_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFrom_list(this); + } +}; + +From_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFrom_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.From_listContext = From_listContext; + +PostgreSQLParser.prototype.from_list = function() { + + var localctx = new From_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1050, PostgreSQLParser.RULE_from_list); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8193; + this.table_ref(); + this.state = 8198; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,453,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 8194; + this.match(PostgreSQLParser.COMMA); + this.state = 8195; + this.table_ref(); + } + this.state = 8200; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,453,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Table_refContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_table_ref; + return this; +} + +Table_refContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Table_refContext.prototype.constructor = Table_refContext; + +Table_refContext.prototype.relation_expr = function() { + return this.getTypedRuleContext(Relation_exprContext,0); +}; + +Table_refContext.prototype.opt_alias_clause = function() { + return this.getTypedRuleContext(Opt_alias_clauseContext,0); +}; + +Table_refContext.prototype.func_table = function() { + return this.getTypedRuleContext(Func_tableContext,0); +}; + +Table_refContext.prototype.func_alias_clause = function() { + return this.getTypedRuleContext(Func_alias_clauseContext,0); +}; + +Table_refContext.prototype.xmltable = function() { + return this.getTypedRuleContext(XmltableContext,0); +}; + +Table_refContext.prototype.select_with_parens = function() { + return this.getTypedRuleContext(Select_with_parensContext,0); +}; + +Table_refContext.prototype.LATERAL_P = function() { + return this.getToken(PostgreSQLParser.LATERAL_P, 0); +}; + +Table_refContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Table_refContext.prototype.table_ref = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Table_refContext); + } else { + return this.getTypedRuleContext(Table_refContext,i); + } +}; + +Table_refContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Table_refContext.prototype.CROSS = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.CROSS); + } else { + return this.getToken(PostgreSQLParser.CROSS, i); + } +}; + + +Table_refContext.prototype.JOIN = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.JOIN); + } else { + return this.getToken(PostgreSQLParser.JOIN, i); + } +}; + + +Table_refContext.prototype.NATURAL = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.NATURAL); + } else { + return this.getToken(PostgreSQLParser.NATURAL, i); + } +}; + + +Table_refContext.prototype.join_qual = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Join_qualContext); + } else { + return this.getTypedRuleContext(Join_qualContext,i); + } +}; + +Table_refContext.prototype.tablesample_clause = function() { + return this.getTypedRuleContext(Tablesample_clauseContext,0); +}; + +Table_refContext.prototype.join_type = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Join_typeContext); + } else { + return this.getTypedRuleContext(Join_typeContext,i); + } +}; + +Table_refContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTable_ref(this); + } +}; + +Table_refContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTable_ref(this); + } +}; + +Table_refContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTable_ref(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Table_refContext = Table_refContext; + +PostgreSQLParser.prototype.table_ref = function() { + + var localctx = new Table_refContext(this, this._ctx, this.state); + this.enterRule(localctx, 1052, PostgreSQLParser.RULE_table_ref); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8250; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,459,this._ctx); + switch(la_) { + case 1: + this.state = 8201; + this.relation_expr(); + this.state = 8202; + this.opt_alias_clause(); + this.state = 8204; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.TABLESAMPLE) { + this.state = 8203; + this.tablesample_clause(); + } + + break; + + case 2: + this.state = 8206; + this.func_table(); + this.state = 8207; + this.func_alias_clause(); + break; + + case 3: + this.state = 8209; + this.xmltable(); + this.state = 8210; + this.opt_alias_clause(); + break; + + case 4: + this.state = 8212; + this.select_with_parens(); + this.state = 8213; + this.opt_alias_clause(); + break; + + case 5: + this.state = 8215; + this.match(PostgreSQLParser.LATERAL_P); + this.state = 8225; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,455,this._ctx); + switch(la_) { + case 1: + this.state = 8216; + this.xmltable(); + this.state = 8217; + this.opt_alias_clause(); + break; + + case 2: + this.state = 8219; + this.func_table(); + this.state = 8220; + this.func_alias_clause(); + break; + + case 3: + this.state = 8222; + this.select_with_parens(); + this.state = 8223; + this.opt_alias_clause(); + break; + + } + break; + + case 6: + this.state = 8227; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8228; + this.table_ref(); + this.state = 8245; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case PostgreSQLParser.CROSS: + this.state = 8229; + this.match(PostgreSQLParser.CROSS); + this.state = 8230; + this.match(PostgreSQLParser.JOIN); + this.state = 8231; + this.table_ref(); + break; + case PostgreSQLParser.NATURAL: + this.state = 8232; + this.match(PostgreSQLParser.NATURAL); + this.state = 8234; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(((((_la - 113)) & ~0x1f) == 0 && ((1 << (_la - 113)) & ((1 << (PostgreSQLParser.FULL - 113)) | (1 << (PostgreSQLParser.INNER_P - 113)) | (1 << (PostgreSQLParser.LEFT - 113)) | (1 << (PostgreSQLParser.RIGHT - 113)))) !== 0)) { + this.state = 8233; + this.join_type(); + } + + this.state = 8236; + this.match(PostgreSQLParser.JOIN); + this.state = 8237; + this.table_ref(); + break; + case PostgreSQLParser.FULL: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.RIGHT: + this.state = 8239; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(((((_la - 113)) & ~0x1f) == 0 && ((1 << (_la - 113)) & ((1 << (PostgreSQLParser.FULL - 113)) | (1 << (PostgreSQLParser.INNER_P - 113)) | (1 << (PostgreSQLParser.LEFT - 113)) | (1 << (PostgreSQLParser.RIGHT - 113)))) !== 0)) { + this.state = 8238; + this.join_type(); + } + + this.state = 8241; + this.match(PostgreSQLParser.JOIN); + this.state = 8242; + this.table_ref(); + this.state = 8243; + this.join_qual(); + break; + case PostgreSQLParser.CLOSE_PAREN: + break; + default: + break; + } + this.state = 8247; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 8248; + this.opt_alias_clause(); + break; + + } + this.state = 8270; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,463,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 8268; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CROSS: + this.state = 8252; + this.match(PostgreSQLParser.CROSS); + this.state = 8253; + this.match(PostgreSQLParser.JOIN); + this.state = 8254; + this.table_ref(); + break; + case PostgreSQLParser.NATURAL: + this.state = 8255; + this.match(PostgreSQLParser.NATURAL); + this.state = 8257; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(((((_la - 113)) & ~0x1f) == 0 && ((1 << (_la - 113)) & ((1 << (PostgreSQLParser.FULL - 113)) | (1 << (PostgreSQLParser.INNER_P - 113)) | (1 << (PostgreSQLParser.LEFT - 113)) | (1 << (PostgreSQLParser.RIGHT - 113)))) !== 0)) { + this.state = 8256; + this.join_type(); + } + + this.state = 8259; + this.match(PostgreSQLParser.JOIN); + this.state = 8260; + this.table_ref(); + break; + case PostgreSQLParser.FULL: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.RIGHT: + this.state = 8262; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(((((_la - 113)) & ~0x1f) == 0 && ((1 << (_la - 113)) & ((1 << (PostgreSQLParser.FULL - 113)) | (1 << (PostgreSQLParser.INNER_P - 113)) | (1 << (PostgreSQLParser.LEFT - 113)) | (1 << (PostgreSQLParser.RIGHT - 113)))) !== 0)) { + this.state = 8261; + this.join_type(); + } + + this.state = 8264; + this.match(PostgreSQLParser.JOIN); + this.state = 8265; + this.table_ref(); + this.state = 8266; + this.join_qual(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } + this.state = 8272; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,463,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Alias_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_alias_clause; + return this; +} + +Alias_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Alias_clauseContext.prototype.constructor = Alias_clauseContext; + +Alias_clauseContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Alias_clauseContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Alias_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Alias_clauseContext.prototype.name_list = function() { + return this.getTypedRuleContext(Name_listContext,0); +}; + +Alias_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Alias_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAlias_clause(this); + } +}; + +Alias_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAlias_clause(this); + } +}; + +Alias_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAlias_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Alias_clauseContext = Alias_clauseContext; + +PostgreSQLParser.prototype.alias_clause = function() { + + var localctx = new Alias_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1054, PostgreSQLParser.RULE_alias_clause); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8274; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.AS) { + this.state = 8273; + this.match(PostgreSQLParser.AS); + } + + this.state = 8276; + this.colid(); + this.state = 8281; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,465,this._ctx); + if(la_===1) { + this.state = 8277; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8278; + this.name_list(); + this.state = 8279; + this.match(PostgreSQLParser.CLOSE_PAREN); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_alias_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_alias_clause; + return this; +} + +Opt_alias_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_alias_clauseContext.prototype.constructor = Opt_alias_clauseContext; + +Opt_alias_clauseContext.prototype.alias_clause = function() { + return this.getTypedRuleContext(Alias_clauseContext,0); +}; + +Opt_alias_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_alias_clause(this); + } +}; + +Opt_alias_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_alias_clause(this); + } +}; + +Opt_alias_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_alias_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_alias_clauseContext = Opt_alias_clauseContext; + +PostgreSQLParser.prototype.opt_alias_clause = function() { + + var localctx = new Opt_alias_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1056, PostgreSQLParser.RULE_opt_alias_clause); + try { + this.state = 8285; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,466,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8283; + this.alias_clause(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_alias_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_alias_clause; + return this; +} + +Func_alias_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_alias_clauseContext.prototype.constructor = Func_alias_clauseContext; + +Func_alias_clauseContext.prototype.alias_clause = function() { + return this.getTypedRuleContext(Alias_clauseContext,0); +}; + +Func_alias_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Func_alias_clauseContext.prototype.tablefuncelementlist = function() { + return this.getTypedRuleContext(TablefuncelementlistContext,0); +}; + +Func_alias_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Func_alias_clauseContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Func_alias_clauseContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Func_alias_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_alias_clause(this); + } +}; + +Func_alias_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_alias_clause(this); + } +}; + +Func_alias_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_alias_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_alias_clauseContext = Func_alias_clauseContext; + +PostgreSQLParser.prototype.func_alias_clause = function() { + + var localctx = new Func_alias_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1058, PostgreSQLParser.RULE_func_alias_clause); + var _la = 0; // Token type + try { + this.state = 8300; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,469,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8287; + this.alias_clause(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8293; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AS: + this.state = 8288; + this.match(PostgreSQLParser.AS); + this.state = 8290; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(((((_la - 33)) & ~0x1f) == 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.AND - 33)) | (1 << (PostgreSQLParser.ARRAY - 33)) | (1 << (PostgreSQLParser.COLLATE - 33)) | (1 << (PostgreSQLParser.COLUMN - 33)) | (1 << (PostgreSQLParser.CONSTRAINT - 33)) | (1 << (PostgreSQLParser.DEFAULT - 33)) | (1 << (PostgreSQLParser.DO - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1f) == 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.TABLE - 92)) | (1 << (PostgreSQLParser.IS - 92)) | (1 << (PostgreSQLParser.OUTER_P - 92)))) !== 0) || ((((_la - 124)) & ~0x1f) == 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.OVER - 124)) | (1 << (PostgreSQLParser.ABORT_P - 124)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 124)) | (1 << (PostgreSQLParser.ACCESS - 124)) | (1 << (PostgreSQLParser.ACTION - 124)) | (1 << (PostgreSQLParser.ADD_P - 124)) | (1 << (PostgreSQLParser.ADMIN - 124)) | (1 << (PostgreSQLParser.AFTER - 124)) | (1 << (PostgreSQLParser.AGGREGATE - 124)) | (1 << (PostgreSQLParser.ALSO - 124)) | (1 << (PostgreSQLParser.ALTER - 124)) | (1 << (PostgreSQLParser.ALWAYS - 124)) | (1 << (PostgreSQLParser.ASSERTION - 124)) | (1 << (PostgreSQLParser.ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.AT - 124)) | (1 << (PostgreSQLParser.ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.BACKWARD - 124)) | (1 << (PostgreSQLParser.BEFORE - 124)) | (1 << (PostgreSQLParser.BEGIN_P - 124)) | (1 << (PostgreSQLParser.BY - 124)) | (1 << (PostgreSQLParser.CACHE - 124)) | (1 << (PostgreSQLParser.CALLED - 124)) | (1 << (PostgreSQLParser.CASCADE - 124)) | (1 << (PostgreSQLParser.CASCADED - 124)) | (1 << (PostgreSQLParser.CATALOG - 124)) | (1 << (PostgreSQLParser.CHAIN - 124)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1f) == 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.CLASS - 156)) | (1 << (PostgreSQLParser.CLOSE - 156)) | (1 << (PostgreSQLParser.CLUSTER - 156)) | (1 << (PostgreSQLParser.COMMENT - 156)) | (1 << (PostgreSQLParser.COMMENTS - 156)) | (1 << (PostgreSQLParser.COMMIT - 156)) | (1 << (PostgreSQLParser.COMMITTED - 156)) | (1 << (PostgreSQLParser.CONFIGURATION - 156)) | (1 << (PostgreSQLParser.CONNECTION - 156)) | (1 << (PostgreSQLParser.CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.CONTENT_P - 156)) | (1 << (PostgreSQLParser.CONTINUE_P - 156)) | (1 << (PostgreSQLParser.CONVERSION_P - 156)) | (1 << (PostgreSQLParser.COPY - 156)) | (1 << (PostgreSQLParser.COST - 156)) | (1 << (PostgreSQLParser.CSV - 156)) | (1 << (PostgreSQLParser.CURSOR - 156)) | (1 << (PostgreSQLParser.CYCLE - 156)) | (1 << (PostgreSQLParser.DATA_P - 156)) | (1 << (PostgreSQLParser.DATABASE - 156)) | (1 << (PostgreSQLParser.DAY_P - 156)) | (1 << (PostgreSQLParser.DEALLOCATE - 156)) | (1 << (PostgreSQLParser.DECLARE - 156)) | (1 << (PostgreSQLParser.DEFAULTS - 156)) | (1 << (PostgreSQLParser.DEFERRED - 156)) | (1 << (PostgreSQLParser.DEFINER - 156)) | (1 << (PostgreSQLParser.DELETE_P - 156)) | (1 << (PostgreSQLParser.DELIMITER - 156)) | (1 << (PostgreSQLParser.DELIMITERS - 156)) | (1 << (PostgreSQLParser.DICTIONARY - 156)) | (1 << (PostgreSQLParser.DISABLE_P - 156)) | (1 << (PostgreSQLParser.DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1f) == 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.DOCUMENT_P - 188)) | (1 << (PostgreSQLParser.DOMAIN_P - 188)) | (1 << (PostgreSQLParser.DOUBLE_P - 188)) | (1 << (PostgreSQLParser.DROP - 188)) | (1 << (PostgreSQLParser.EACH - 188)) | (1 << (PostgreSQLParser.ENABLE_P - 188)) | (1 << (PostgreSQLParser.ENCODING - 188)) | (1 << (PostgreSQLParser.ENCRYPTED - 188)) | (1 << (PostgreSQLParser.ENUM_P - 188)) | (1 << (PostgreSQLParser.ESCAPE - 188)) | (1 << (PostgreSQLParser.EVENT - 188)) | (1 << (PostgreSQLParser.EXCLUDE - 188)) | (1 << (PostgreSQLParser.EXCLUDING - 188)) | (1 << (PostgreSQLParser.EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.EXECUTE - 188)) | (1 << (PostgreSQLParser.EXPLAIN - 188)) | (1 << (PostgreSQLParser.EXTENSION - 188)) | (1 << (PostgreSQLParser.EXTERNAL - 188)) | (1 << (PostgreSQLParser.FAMILY - 188)) | (1 << (PostgreSQLParser.FIRST_P - 188)) | (1 << (PostgreSQLParser.FOLLOWING - 188)) | (1 << (PostgreSQLParser.FORCE - 188)) | (1 << (PostgreSQLParser.FORWARD - 188)) | (1 << (PostgreSQLParser.FUNCTION - 188)) | (1 << (PostgreSQLParser.FUNCTIONS - 188)) | (1 << (PostgreSQLParser.GLOBAL - 188)) | (1 << (PostgreSQLParser.GRANTED - 188)) | (1 << (PostgreSQLParser.HANDLER - 188)) | (1 << (PostgreSQLParser.HEADER_P - 188)) | (1 << (PostgreSQLParser.HOLD - 188)) | (1 << (PostgreSQLParser.HOUR_P - 188)) | (1 << (PostgreSQLParser.IDENTITY_P - 188)))) !== 0) || ((((_la - 220)) & ~0x1f) == 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.IF_P - 220)) | (1 << (PostgreSQLParser.IMMEDIATE - 220)) | (1 << (PostgreSQLParser.IMMUTABLE - 220)) | (1 << (PostgreSQLParser.IMPLICIT_P - 220)) | (1 << (PostgreSQLParser.INCLUDING - 220)) | (1 << (PostgreSQLParser.INCREMENT - 220)) | (1 << (PostgreSQLParser.INDEX - 220)) | (1 << (PostgreSQLParser.INDEXES - 220)) | (1 << (PostgreSQLParser.INHERIT - 220)) | (1 << (PostgreSQLParser.INHERITS - 220)) | (1 << (PostgreSQLParser.INLINE_P - 220)) | (1 << (PostgreSQLParser.INSENSITIVE - 220)) | (1 << (PostgreSQLParser.INSERT - 220)) | (1 << (PostgreSQLParser.INSTEAD - 220)) | (1 << (PostgreSQLParser.INVOKER - 220)) | (1 << (PostgreSQLParser.ISOLATION - 220)) | (1 << (PostgreSQLParser.KEY - 220)) | (1 << (PostgreSQLParser.LABEL - 220)) | (1 << (PostgreSQLParser.LANGUAGE - 220)) | (1 << (PostgreSQLParser.LARGE_P - 220)) | (1 << (PostgreSQLParser.LAST_P - 220)) | (1 << (PostgreSQLParser.LEAKPROOF - 220)) | (1 << (PostgreSQLParser.LEVEL - 220)) | (1 << (PostgreSQLParser.LISTEN - 220)) | (1 << (PostgreSQLParser.LOAD - 220)) | (1 << (PostgreSQLParser.LOCAL - 220)) | (1 << (PostgreSQLParser.LOCATION - 220)) | (1 << (PostgreSQLParser.LOCK_P - 220)) | (1 << (PostgreSQLParser.MAPPING - 220)) | (1 << (PostgreSQLParser.MATCH - 220)) | (1 << (PostgreSQLParser.MATERIALIZED - 220)) | (1 << (PostgreSQLParser.MAXVALUE - 220)))) !== 0) || ((((_la - 252)) & ~0x1f) == 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.MINUTE_P - 252)) | (1 << (PostgreSQLParser.MINVALUE - 252)) | (1 << (PostgreSQLParser.MODE - 252)) | (1 << (PostgreSQLParser.MONTH_P - 252)) | (1 << (PostgreSQLParser.MOVE - 252)) | (1 << (PostgreSQLParser.NAME_P - 252)) | (1 << (PostgreSQLParser.NAMES - 252)) | (1 << (PostgreSQLParser.NEXT - 252)) | (1 << (PostgreSQLParser.NO - 252)) | (1 << (PostgreSQLParser.NOTHING - 252)) | (1 << (PostgreSQLParser.NOTIFY - 252)) | (1 << (PostgreSQLParser.NOWAIT - 252)) | (1 << (PostgreSQLParser.NULLS_P - 252)) | (1 << (PostgreSQLParser.OBJECT_P - 252)) | (1 << (PostgreSQLParser.OF - 252)) | (1 << (PostgreSQLParser.OFF - 252)) | (1 << (PostgreSQLParser.OIDS - 252)) | (1 << (PostgreSQLParser.OPERATOR - 252)) | (1 << (PostgreSQLParser.OPTION - 252)) | (1 << (PostgreSQLParser.OPTIONS - 252)) | (1 << (PostgreSQLParser.OWNED - 252)) | (1 << (PostgreSQLParser.OWNER - 252)) | (1 << (PostgreSQLParser.PARSER - 252)) | (1 << (PostgreSQLParser.PARTIAL - 252)) | (1 << (PostgreSQLParser.PARTITION - 252)) | (1 << (PostgreSQLParser.PASSING - 252)) | (1 << (PostgreSQLParser.PASSWORD - 252)) | (1 << (PostgreSQLParser.PLANS - 252)) | (1 << (PostgreSQLParser.PRECEDING - 252)) | (1 << (PostgreSQLParser.PREPARE - 252)) | (1 << (PostgreSQLParser.PREPARED - 252)) | (1 << (PostgreSQLParser.PRESERVE - 252)))) !== 0) || ((((_la - 284)) & ~0x1f) == 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.PRIOR - 284)) | (1 << (PostgreSQLParser.PRIVILEGES - 284)) | (1 << (PostgreSQLParser.PROCEDURAL - 284)) | (1 << (PostgreSQLParser.PROCEDURE - 284)) | (1 << (PostgreSQLParser.PROGRAM - 284)) | (1 << (PostgreSQLParser.QUOTE - 284)) | (1 << (PostgreSQLParser.RANGE - 284)) | (1 << (PostgreSQLParser.READ - 284)) | (1 << (PostgreSQLParser.REASSIGN - 284)) | (1 << (PostgreSQLParser.RECHECK - 284)) | (1 << (PostgreSQLParser.RECURSIVE - 284)) | (1 << (PostgreSQLParser.REF - 284)) | (1 << (PostgreSQLParser.REFRESH - 284)) | (1 << (PostgreSQLParser.REINDEX - 284)) | (1 << (PostgreSQLParser.RELATIVE_P - 284)) | (1 << (PostgreSQLParser.RELEASE - 284)) | (1 << (PostgreSQLParser.RENAME - 284)) | (1 << (PostgreSQLParser.REPEATABLE - 284)) | (1 << (PostgreSQLParser.REPLACE - 284)) | (1 << (PostgreSQLParser.REPLICA - 284)) | (1 << (PostgreSQLParser.RESET - 284)) | (1 << (PostgreSQLParser.RESTART - 284)) | (1 << (PostgreSQLParser.RESTRICT - 284)) | (1 << (PostgreSQLParser.RETURNS - 284)) | (1 << (PostgreSQLParser.REVOKE - 284)) | (1 << (PostgreSQLParser.ROLE - 284)) | (1 << (PostgreSQLParser.ROLLBACK - 284)) | (1 << (PostgreSQLParser.ROWS - 284)) | (1 << (PostgreSQLParser.RULE - 284)) | (1 << (PostgreSQLParser.SAVEPOINT - 284)) | (1 << (PostgreSQLParser.SCHEMA - 284)) | (1 << (PostgreSQLParser.SCROLL - 284)))) !== 0) || ((((_la - 316)) & ~0x1f) == 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.SEARCH - 316)) | (1 << (PostgreSQLParser.SECOND_P - 316)) | (1 << (PostgreSQLParser.SECURITY - 316)) | (1 << (PostgreSQLParser.SEQUENCE - 316)) | (1 << (PostgreSQLParser.SEQUENCES - 316)) | (1 << (PostgreSQLParser.SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.SERVER - 316)) | (1 << (PostgreSQLParser.SESSION - 316)) | (1 << (PostgreSQLParser.SET - 316)) | (1 << (PostgreSQLParser.SHARE - 316)) | (1 << (PostgreSQLParser.SHOW - 316)) | (1 << (PostgreSQLParser.SIMPLE - 316)) | (1 << (PostgreSQLParser.SNAPSHOT - 316)) | (1 << (PostgreSQLParser.STABLE - 316)) | (1 << (PostgreSQLParser.STANDALONE_P - 316)) | (1 << (PostgreSQLParser.START - 316)) | (1 << (PostgreSQLParser.STATEMENT - 316)) | (1 << (PostgreSQLParser.STATISTICS - 316)) | (1 << (PostgreSQLParser.STDIN - 316)) | (1 << (PostgreSQLParser.STDOUT - 316)) | (1 << (PostgreSQLParser.STORAGE - 316)) | (1 << (PostgreSQLParser.STRICT_P - 316)) | (1 << (PostgreSQLParser.STRIP_P - 316)) | (1 << (PostgreSQLParser.SYSID - 316)) | (1 << (PostgreSQLParser.SYSTEM_P - 316)) | (1 << (PostgreSQLParser.TABLES - 316)) | (1 << (PostgreSQLParser.TABLESPACE - 316)) | (1 << (PostgreSQLParser.TEMP - 316)) | (1 << (PostgreSQLParser.TEMPLATE - 316)) | (1 << (PostgreSQLParser.TEMPORARY - 316)) | (1 << (PostgreSQLParser.TEXT_P - 316)) | (1 << (PostgreSQLParser.TRANSACTION - 316)))) !== 0) || ((((_la - 348)) & ~0x1f) == 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.TRIGGER - 348)) | (1 << (PostgreSQLParser.TRUNCATE - 348)) | (1 << (PostgreSQLParser.TRUSTED - 348)) | (1 << (PostgreSQLParser.TYPE_P - 348)) | (1 << (PostgreSQLParser.TYPES_P - 348)) | (1 << (PostgreSQLParser.UNBOUNDED - 348)) | (1 << (PostgreSQLParser.UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.UNKNOWN - 348)) | (1 << (PostgreSQLParser.UNLISTEN - 348)) | (1 << (PostgreSQLParser.UNLOGGED - 348)) | (1 << (PostgreSQLParser.UNTIL - 348)) | (1 << (PostgreSQLParser.UPDATE - 348)) | (1 << (PostgreSQLParser.VACUUM - 348)) | (1 << (PostgreSQLParser.VALID - 348)) | (1 << (PostgreSQLParser.VALIDATE - 348)) | (1 << (PostgreSQLParser.VALIDATOR - 348)) | (1 << (PostgreSQLParser.VARYING - 348)) | (1 << (PostgreSQLParser.VERSION_P - 348)) | (1 << (PostgreSQLParser.VIEW - 348)) | (1 << (PostgreSQLParser.VOLATILE - 348)) | (1 << (PostgreSQLParser.WHITESPACE_P - 348)) | (1 << (PostgreSQLParser.WITHOUT - 348)) | (1 << (PostgreSQLParser.WORK - 348)) | (1 << (PostgreSQLParser.WRAPPER - 348)) | (1 << (PostgreSQLParser.WRITE - 348)) | (1 << (PostgreSQLParser.XML_P - 348)) | (1 << (PostgreSQLParser.YEAR_P - 348)) | (1 << (PostgreSQLParser.YES_P - 348)) | (1 << (PostgreSQLParser.ZONE - 348)) | (1 << (PostgreSQLParser.BETWEEN - 348)) | (1 << (PostgreSQLParser.BIGINT - 348)))) !== 0) || ((((_la - 380)) & ~0x1f) == 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.BIT - 380)) | (1 << (PostgreSQLParser.BOOLEAN_P - 380)) | (1 << (PostgreSQLParser.CHAR_P - 380)) | (1 << (PostgreSQLParser.CHARACTER - 380)) | (1 << (PostgreSQLParser.COALESCE - 380)) | (1 << (PostgreSQLParser.DEC - 380)) | (1 << (PostgreSQLParser.DECIMAL_P - 380)) | (1 << (PostgreSQLParser.EXISTS - 380)) | (1 << (PostgreSQLParser.EXTRACT - 380)) | (1 << (PostgreSQLParser.FLOAT_P - 380)) | (1 << (PostgreSQLParser.GREATEST - 380)) | (1 << (PostgreSQLParser.INOUT - 380)) | (1 << (PostgreSQLParser.INT_P - 380)) | (1 << (PostgreSQLParser.INTEGER - 380)) | (1 << (PostgreSQLParser.INTERVAL - 380)) | (1 << (PostgreSQLParser.LEAST - 380)) | (1 << (PostgreSQLParser.NATIONAL - 380)) | (1 << (PostgreSQLParser.NCHAR - 380)) | (1 << (PostgreSQLParser.NONE - 380)) | (1 << (PostgreSQLParser.NULLIF - 380)) | (1 << (PostgreSQLParser.NUMERIC - 380)) | (1 << (PostgreSQLParser.OVERLAY - 380)) | (1 << (PostgreSQLParser.POSITION - 380)) | (1 << (PostgreSQLParser.PRECISION - 380)) | (1 << (PostgreSQLParser.REAL - 380)) | (1 << (PostgreSQLParser.ROW - 380)) | (1 << (PostgreSQLParser.SETOF - 380)) | (1 << (PostgreSQLParser.SMALLINT - 380)) | (1 << (PostgreSQLParser.SUBSTRING - 380)) | (1 << (PostgreSQLParser.TIME - 380)) | (1 << (PostgreSQLParser.TIMESTAMP - 380)) | (1 << (PostgreSQLParser.TREAT - 380)))) !== 0) || ((((_la - 412)) & ~0x1f) == 0 && ((1 << (_la - 412)) & ((1 << (PostgreSQLParser.TRIM - 412)) | (1 << (PostgreSQLParser.VALUES - 412)) | (1 << (PostgreSQLParser.VARCHAR - 412)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 412)) | (1 << (PostgreSQLParser.XMLCONCAT - 412)) | (1 << (PostgreSQLParser.XMLELEMENT - 412)) | (1 << (PostgreSQLParser.XMLEXISTS - 412)) | (1 << (PostgreSQLParser.XMLFOREST - 412)) | (1 << (PostgreSQLParser.XMLPARSE - 412)) | (1 << (PostgreSQLParser.XMLPI - 412)) | (1 << (PostgreSQLParser.XMLROOT - 412)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 412)) | (1 << (PostgreSQLParser.CALL - 412)) | (1 << (PostgreSQLParser.CURRENT_P - 412)) | (1 << (PostgreSQLParser.ATTACH - 412)) | (1 << (PostgreSQLParser.DETACH - 412)) | (1 << (PostgreSQLParser.EXPRESSION - 412)) | (1 << (PostgreSQLParser.GENERATED - 412)) | (1 << (PostgreSQLParser.LOGGED - 412)) | (1 << (PostgreSQLParser.STORED - 412)) | (1 << (PostgreSQLParser.INCLUDE - 412)) | (1 << (PostgreSQLParser.ROUTINE - 412)) | (1 << (PostgreSQLParser.TRANSFORM - 412)) | (1 << (PostgreSQLParser.IMPORT_P - 412)) | (1 << (PostgreSQLParser.POLICY - 412)) | (1 << (PostgreSQLParser.METHOD - 412)) | (1 << (PostgreSQLParser.REFERENCING - 412)) | (1 << (PostgreSQLParser.NEW - 412)) | (1 << (PostgreSQLParser.OLD - 412)) | (1 << (PostgreSQLParser.VALUE_P - 412)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 412)) | (1 << (PostgreSQLParser.PUBLICATION - 412)))) !== 0) || ((((_la - 444)) & ~0x1f) == 0 && ((1 << (_la - 444)) & ((1 << (PostgreSQLParser.OUT_P - 444)) | (1 << (PostgreSQLParser.ROUTINES - 444)) | (1 << (PostgreSQLParser.SCHEMAS - 444)) | (1 << (PostgreSQLParser.PROCEDURES - 444)) | (1 << (PostgreSQLParser.INPUT_P - 444)) | (1 << (PostgreSQLParser.SUPPORT - 444)) | (1 << (PostgreSQLParser.PARALLEL - 444)) | (1 << (PostgreSQLParser.SQL_P - 444)) | (1 << (PostgreSQLParser.DEPENDS - 444)) | (1 << (PostgreSQLParser.OVERRIDING - 444)) | (1 << (PostgreSQLParser.CONFLICT - 444)) | (1 << (PostgreSQLParser.SKIP_P - 444)) | (1 << (PostgreSQLParser.LOCKED - 444)) | (1 << (PostgreSQLParser.TIES - 444)) | (1 << (PostgreSQLParser.ROLLUP - 444)) | (1 << (PostgreSQLParser.CUBE - 444)) | (1 << (PostgreSQLParser.GROUPING - 444)) | (1 << (PostgreSQLParser.SETS - 444)) | (1 << (PostgreSQLParser.ORDINALITY - 444)) | (1 << (PostgreSQLParser.XMLTABLE - 444)) | (1 << (PostgreSQLParser.COLUMNS - 444)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 444)) | (1 << (PostgreSQLParser.ROWTYPE - 444)) | (1 << (PostgreSQLParser.NORMALIZED - 444)) | (1 << (PostgreSQLParser.WITHIN - 444)) | (1 << (PostgreSQLParser.FILTER - 444)) | (1 << (PostgreSQLParser.GROUPS - 444)) | (1 << (PostgreSQLParser.OTHERS - 444)) | (1 << (PostgreSQLParser.NFC - 444)) | (1 << (PostgreSQLParser.NFD - 444)))) !== 0) || ((((_la - 476)) & ~0x1f) == 0 && ((1 << (_la - 476)) & ((1 << (PostgreSQLParser.NFKC - 476)) | (1 << (PostgreSQLParser.NFKD - 476)) | (1 << (PostgreSQLParser.UESCAPE - 476)) | (1 << (PostgreSQLParser.VIEWS - 476)) | (1 << (PostgreSQLParser.NORMALIZE - 476)) | (1 << (PostgreSQLParser.DUMP - 476)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 476)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 476)) | (1 << (PostgreSQLParser.ERROR - 476)) | (1 << (PostgreSQLParser.USE_VARIABLE - 476)) | (1 << (PostgreSQLParser.USE_COLUMN - 476)) | (1 << (PostgreSQLParser.ALIAS - 476)) | (1 << (PostgreSQLParser.CONSTANT - 476)) | (1 << (PostgreSQLParser.PERFORM - 476)) | (1 << (PostgreSQLParser.GET - 476)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 476)) | (1 << (PostgreSQLParser.STACKED - 476)) | (1 << (PostgreSQLParser.ELSIF - 476)) | (1 << (PostgreSQLParser.REVERSE - 476)) | (1 << (PostgreSQLParser.SLICE - 476)) | (1 << (PostgreSQLParser.EXIT - 476)) | (1 << (PostgreSQLParser.RETURN - 476)) | (1 << (PostgreSQLParser.QUERY - 476)) | (1 << (PostgreSQLParser.RAISE - 476)) | (1 << (PostgreSQLParser.SQLSTATE - 476)) | (1 << (PostgreSQLParser.DEBUG - 476)) | (1 << (PostgreSQLParser.LOG - 476)) | (1 << (PostgreSQLParser.INFO - 476)) | (1 << (PostgreSQLParser.NOTICE - 476)) | (1 << (PostgreSQLParser.WARNING - 476)))) !== 0) || ((((_la - 508)) & ~0x1f) == 0 && ((1 << (_la - 508)) & ((1 << (PostgreSQLParser.EXCEPTION - 508)) | (1 << (PostgreSQLParser.ASSERT - 508)) | (1 << (PostgreSQLParser.OPEN - 508)) | (1 << (PostgreSQLParser.Identifier - 508)) | (1 << (PostgreSQLParser.QuotedIdentifier - 508)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 508)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 508)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 508)))) !== 0)) { + this.state = 8289; + this.colid(); + } + + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.state = 8292; + this.colid(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 8295; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8296; + this.tablefuncelementlist(); + this.state = 8297; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Join_typeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_join_type; + return this; +} + +Join_typeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Join_typeContext.prototype.constructor = Join_typeContext; + +Join_typeContext.prototype.FULL = function() { + return this.getToken(PostgreSQLParser.FULL, 0); +}; + +Join_typeContext.prototype.LEFT = function() { + return this.getToken(PostgreSQLParser.LEFT, 0); +}; + +Join_typeContext.prototype.RIGHT = function() { + return this.getToken(PostgreSQLParser.RIGHT, 0); +}; + +Join_typeContext.prototype.INNER_P = function() { + return this.getToken(PostgreSQLParser.INNER_P, 0); +}; + +Join_typeContext.prototype.OUTER_P = function() { + return this.getToken(PostgreSQLParser.OUTER_P, 0); +}; + +Join_typeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterJoin_type(this); + } +}; + +Join_typeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitJoin_type(this); + } +}; + +Join_typeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitJoin_type(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Join_typeContext = Join_typeContext; + +PostgreSQLParser.prototype.join_type = function() { + + var localctx = new Join_typeContext(this, this._ctx, this.state); + this.enterRule(localctx, 1060, PostgreSQLParser.RULE_join_type); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8302; + _la = this._input.LA(1); + if(!(((((_la - 113)) & ~0x1f) == 0 && ((1 << (_la - 113)) & ((1 << (PostgreSQLParser.FULL - 113)) | (1 << (PostgreSQLParser.INNER_P - 113)) | (1 << (PostgreSQLParser.LEFT - 113)) | (1 << (PostgreSQLParser.RIGHT - 113)))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8304; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OUTER_P) { + this.state = 8303; + this.match(PostgreSQLParser.OUTER_P); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Join_qualContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_join_qual; + return this; +} + +Join_qualContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Join_qualContext.prototype.constructor = Join_qualContext; + +Join_qualContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Join_qualContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Join_qualContext.prototype.name_list = function() { + return this.getTypedRuleContext(Name_listContext,0); +}; + +Join_qualContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Join_qualContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +Join_qualContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Join_qualContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterJoin_qual(this); + } +}; + +Join_qualContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitJoin_qual(this); + } +}; + +Join_qualContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitJoin_qual(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Join_qualContext = Join_qualContext; + +PostgreSQLParser.prototype.join_qual = function() { + + var localctx = new Join_qualContext(this, this._ctx, this.state); + this.enterRule(localctx, 1062, PostgreSQLParser.RULE_join_qual); + try { + this.state = 8313; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + this.state = 8306; + this.match(PostgreSQLParser.USING); + this.state = 8307; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8308; + this.name_list(); + this.state = 8309; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.ON: + this.enterOuterAlt(localctx, 2); + this.state = 8311; + this.match(PostgreSQLParser.ON); + this.state = 8312; + this.a_expr(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Relation_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_relation_expr; + return this; +} + +Relation_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Relation_exprContext.prototype.constructor = Relation_exprContext; + +Relation_exprContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +Relation_exprContext.prototype.STAR = function() { + return this.getToken(PostgreSQLParser.STAR, 0); +}; + +Relation_exprContext.prototype.ONLY = function() { + return this.getToken(PostgreSQLParser.ONLY, 0); +}; + +Relation_exprContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Relation_exprContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Relation_exprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRelation_expr(this); + } +}; + +Relation_exprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRelation_expr(this); + } +}; + +Relation_exprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRelation_expr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Relation_exprContext = Relation_exprContext; + +PostgreSQLParser.prototype.relation_expr = function() { + + var localctx = new Relation_exprContext(this, this._ctx, this.state); + this.enterRule(localctx, 1064, PostgreSQLParser.RULE_relation_expr); + var _la = 0; // Token type + try { + this.state = 8327; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 8315; + this.qualified_name(); + this.state = 8317; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.STAR) { + this.state = 8316; + this.match(PostgreSQLParser.STAR); + } + + break; + case PostgreSQLParser.ONLY: + this.enterOuterAlt(localctx, 2); + this.state = 8319; + this.match(PostgreSQLParser.ONLY); + this.state = 8325; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.state = 8320; + this.qualified_name(); + break; + case PostgreSQLParser.OPEN_PAREN: + this.state = 8321; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8322; + this.qualified_name(); + this.state = 8323; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Relation_expr_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_relation_expr_list; + return this; +} + +Relation_expr_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Relation_expr_listContext.prototype.constructor = Relation_expr_listContext; + +Relation_expr_listContext.prototype.relation_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Relation_exprContext); + } else { + return this.getTypedRuleContext(Relation_exprContext,i); + } +}; + +Relation_expr_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Relation_expr_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRelation_expr_list(this); + } +}; + +Relation_expr_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRelation_expr_list(this); + } +}; + +Relation_expr_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRelation_expr_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Relation_expr_listContext = Relation_expr_listContext; + +PostgreSQLParser.prototype.relation_expr_list = function() { + + var localctx = new Relation_expr_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1066, PostgreSQLParser.RULE_relation_expr_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8329; + this.relation_expr(); + this.state = 8334; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 8330; + this.match(PostgreSQLParser.COMMA); + this.state = 8331; + this.relation_expr(); + this.state = 8336; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Relation_expr_opt_aliasContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_relation_expr_opt_alias; + return this; +} + +Relation_expr_opt_aliasContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Relation_expr_opt_aliasContext.prototype.constructor = Relation_expr_opt_aliasContext; + +Relation_expr_opt_aliasContext.prototype.relation_expr = function() { + return this.getTypedRuleContext(Relation_exprContext,0); +}; + +Relation_expr_opt_aliasContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Relation_expr_opt_aliasContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Relation_expr_opt_aliasContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRelation_expr_opt_alias(this); + } +}; + +Relation_expr_opt_aliasContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRelation_expr_opt_alias(this); + } +}; + +Relation_expr_opt_aliasContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRelation_expr_opt_alias(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Relation_expr_opt_aliasContext = Relation_expr_opt_aliasContext; + +PostgreSQLParser.prototype.relation_expr_opt_alias = function() { + + var localctx = new Relation_expr_opt_aliasContext(this, this._ctx, this.state); + this.enterRule(localctx, 1068, PostgreSQLParser.RULE_relation_expr_opt_alias); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8337; + this.relation_expr(); + this.state = 8342; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,477,this._ctx); + if(la_===1) { + this.state = 8339; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.AS) { + this.state = 8338; + this.match(PostgreSQLParser.AS); + } + + this.state = 8341; + this.colid(); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Tablesample_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_tablesample_clause; + return this; +} + +Tablesample_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Tablesample_clauseContext.prototype.constructor = Tablesample_clauseContext; + +Tablesample_clauseContext.prototype.TABLESAMPLE = function() { + return this.getToken(PostgreSQLParser.TABLESAMPLE, 0); +}; + +Tablesample_clauseContext.prototype.func_name = function() { + return this.getTypedRuleContext(Func_nameContext,0); +}; + +Tablesample_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Tablesample_clauseContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Tablesample_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Tablesample_clauseContext.prototype.opt_repeatable_clause = function() { + return this.getTypedRuleContext(Opt_repeatable_clauseContext,0); +}; + +Tablesample_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTablesample_clause(this); + } +}; + +Tablesample_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTablesample_clause(this); + } +}; + +Tablesample_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTablesample_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Tablesample_clauseContext = Tablesample_clauseContext; + +PostgreSQLParser.prototype.tablesample_clause = function() { + + var localctx = new Tablesample_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1070, PostgreSQLParser.RULE_tablesample_clause); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8344; + this.match(PostgreSQLParser.TABLESAMPLE); + this.state = 8345; + this.func_name(); + this.state = 8346; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8347; + this.expr_list(); + this.state = 8348; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 8349; + this.opt_repeatable_clause(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_repeatable_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_repeatable_clause; + return this; +} + +Opt_repeatable_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_repeatable_clauseContext.prototype.constructor = Opt_repeatable_clauseContext; + +Opt_repeatable_clauseContext.prototype.REPEATABLE = function() { + return this.getToken(PostgreSQLParser.REPEATABLE, 0); +}; + +Opt_repeatable_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opt_repeatable_clauseContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Opt_repeatable_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opt_repeatable_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_repeatable_clause(this); + } +}; + +Opt_repeatable_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_repeatable_clause(this); + } +}; + +Opt_repeatable_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_repeatable_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_repeatable_clauseContext = Opt_repeatable_clauseContext; + +PostgreSQLParser.prototype.opt_repeatable_clause = function() { + + var localctx = new Opt_repeatable_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1072, PostgreSQLParser.RULE_opt_repeatable_clause); + try { + this.state = 8357; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.REPEATABLE: + this.enterOuterAlt(localctx, 1); + this.state = 8351; + this.match(PostgreSQLParser.REPEATABLE); + this.state = 8352; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8353; + this.a_expr(); + this.state = 8354; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.GROUP_P: + case PostgreSQLParser.HAVING: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.THEN: + case PostgreSQLParser.UNION: + case PostgreSQLParser.USING: + case PostgreSQLParser.WHEN: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.FULL: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_tableContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_table; + return this; +} + +Func_tableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_tableContext.prototype.constructor = Func_tableContext; + +Func_tableContext.prototype.func_expr_windowless = function() { + return this.getTypedRuleContext(Func_expr_windowlessContext,0); +}; + +Func_tableContext.prototype.opt_ordinality = function() { + return this.getTypedRuleContext(Opt_ordinalityContext,0); +}; + +Func_tableContext.prototype.ROWS = function() { + return this.getToken(PostgreSQLParser.ROWS, 0); +}; + +Func_tableContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Func_tableContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Func_tableContext.prototype.rowsfrom_list = function() { + return this.getTypedRuleContext(Rowsfrom_listContext,0); +}; + +Func_tableContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Func_tableContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_table(this); + } +}; + +Func_tableContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_table(this); + } +}; + +Func_tableContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_table(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_tableContext = Func_tableContext; + +PostgreSQLParser.prototype.func_table = function() { + + var localctx = new Func_tableContext(this, this._ctx, this.state); + this.enterRule(localctx, 1074, PostgreSQLParser.RULE_func_table); + try { + this.state = 8369; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,479,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8359; + this.func_expr_windowless(); + this.state = 8360; + this.opt_ordinality(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8362; + this.match(PostgreSQLParser.ROWS); + this.state = 8363; + this.match(PostgreSQLParser.FROM); + this.state = 8364; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8365; + this.rowsfrom_list(); + this.state = 8366; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 8367; + this.opt_ordinality(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Rowsfrom_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rowsfrom_item; + return this; +} + +Rowsfrom_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Rowsfrom_itemContext.prototype.constructor = Rowsfrom_itemContext; + +Rowsfrom_itemContext.prototype.func_expr_windowless = function() { + return this.getTypedRuleContext(Func_expr_windowlessContext,0); +}; + +Rowsfrom_itemContext.prototype.opt_col_def_list = function() { + return this.getTypedRuleContext(Opt_col_def_listContext,0); +}; + +Rowsfrom_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRowsfrom_item(this); + } +}; + +Rowsfrom_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRowsfrom_item(this); + } +}; + +Rowsfrom_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRowsfrom_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Rowsfrom_itemContext = Rowsfrom_itemContext; + +PostgreSQLParser.prototype.rowsfrom_item = function() { + + var localctx = new Rowsfrom_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 1076, PostgreSQLParser.RULE_rowsfrom_item); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8371; + this.func_expr_windowless(); + this.state = 8372; + this.opt_col_def_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Rowsfrom_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rowsfrom_list; + return this; +} + +Rowsfrom_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Rowsfrom_listContext.prototype.constructor = Rowsfrom_listContext; + +Rowsfrom_listContext.prototype.rowsfrom_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Rowsfrom_itemContext); + } else { + return this.getTypedRuleContext(Rowsfrom_itemContext,i); + } +}; + +Rowsfrom_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Rowsfrom_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRowsfrom_list(this); + } +}; + +Rowsfrom_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRowsfrom_list(this); + } +}; + +Rowsfrom_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRowsfrom_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Rowsfrom_listContext = Rowsfrom_listContext; + +PostgreSQLParser.prototype.rowsfrom_list = function() { + + var localctx = new Rowsfrom_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1078, PostgreSQLParser.RULE_rowsfrom_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8374; + this.rowsfrom_item(); + this.state = 8379; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 8375; + this.match(PostgreSQLParser.COMMA); + this.state = 8376; + this.rowsfrom_item(); + this.state = 8381; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_col_def_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_col_def_list; + return this; +} + +Opt_col_def_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_col_def_listContext.prototype.constructor = Opt_col_def_listContext; + +Opt_col_def_listContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Opt_col_def_listContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opt_col_def_listContext.prototype.tablefuncelementlist = function() { + return this.getTypedRuleContext(TablefuncelementlistContext,0); +}; + +Opt_col_def_listContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opt_col_def_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_col_def_list(this); + } +}; + +Opt_col_def_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_col_def_list(this); + } +}; + +Opt_col_def_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_col_def_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_col_def_listContext = Opt_col_def_listContext; + +PostgreSQLParser.prototype.opt_col_def_list = function() { + + var localctx = new Opt_col_def_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1080, PostgreSQLParser.RULE_opt_col_def_list); + try { + this.state = 8388; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AS: + this.enterOuterAlt(localctx, 1); + this.state = 8382; + this.match(PostgreSQLParser.AS); + this.state = 8383; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8384; + this.tablefuncelementlist(); + this.state = 8385; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_ordinalityContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_ordinality; + return this; +} + +Opt_ordinalityContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_ordinalityContext.prototype.constructor = Opt_ordinalityContext; + +Opt_ordinalityContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Opt_ordinalityContext.prototype.ORDINALITY = function() { + return this.getToken(PostgreSQLParser.ORDINALITY, 0); +}; + +Opt_ordinalityContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_ordinality(this); + } +}; + +Opt_ordinalityContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_ordinality(this); + } +}; + +Opt_ordinalityContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_ordinality(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_ordinalityContext = Opt_ordinalityContext; + +PostgreSQLParser.prototype.opt_ordinality = function() { + + var localctx = new Opt_ordinalityContext(this, this._ctx, this.state); + this.enterRule(localctx, 1082, PostgreSQLParser.RULE_opt_ordinality); + try { + this.state = 8393; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,482,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8390; + this.match(PostgreSQLParser.WITH); + this.state = 8391; + this.match(PostgreSQLParser.ORDINALITY); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Where_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_where_clause; + return this; +} + +Where_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Where_clauseContext.prototype.constructor = Where_clauseContext; + +Where_clauseContext.prototype.WHERE = function() { + return this.getToken(PostgreSQLParser.WHERE, 0); +}; + +Where_clauseContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Where_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterWhere_clause(this); + } +}; + +Where_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitWhere_clause(this); + } +}; + +Where_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitWhere_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Where_clauseContext = Where_clauseContext; + +PostgreSQLParser.prototype.where_clause = function() { + + var localctx = new Where_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1084, PostgreSQLParser.RULE_where_clause); + try { + this.state = 8398; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.WHERE: + this.enterOuterAlt(localctx, 1); + this.state = 8395; + this.match(PostgreSQLParser.WHERE); + this.state = 8396; + this.a_expr(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.GROUP_P: + case PostgreSQLParser.HAVING: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.THEN: + case PostgreSQLParser.UNION: + case PostgreSQLParser.USING: + case PostgreSQLParser.WHEN: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Where_or_current_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_where_or_current_clause; + return this; +} + +Where_or_current_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Where_or_current_clauseContext.prototype.constructor = Where_or_current_clauseContext; + +Where_or_current_clauseContext.prototype.WHERE = function() { + return this.getToken(PostgreSQLParser.WHERE, 0); +}; + +Where_or_current_clauseContext.prototype.CURRENT_P = function() { + return this.getToken(PostgreSQLParser.CURRENT_P, 0); +}; + +Where_or_current_clauseContext.prototype.OF = function() { + return this.getToken(PostgreSQLParser.OF, 0); +}; + +Where_or_current_clauseContext.prototype.cursor_name = function() { + return this.getTypedRuleContext(Cursor_nameContext,0); +}; + +Where_or_current_clauseContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Where_or_current_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterWhere_or_current_clause(this); + } +}; + +Where_or_current_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitWhere_or_current_clause(this); + } +}; + +Where_or_current_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitWhere_or_current_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Where_or_current_clauseContext = Where_or_current_clauseContext; + +PostgreSQLParser.prototype.where_or_current_clause = function() { + + var localctx = new Where_or_current_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1086, PostgreSQLParser.RULE_where_or_current_clause); + try { + this.state = 8408; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.WHERE: + this.enterOuterAlt(localctx, 1); + this.state = 8400; + this.match(PostgreSQLParser.WHERE); + this.state = 8405; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,484,this._ctx); + switch(la_) { + case 1: + this.state = 8401; + this.match(PostgreSQLParser.CURRENT_P); + this.state = 8402; + this.match(PostgreSQLParser.OF); + this.state = 8403; + this.cursor_name(); + break; + + case 2: + this.state = 8404; + this.a_expr(); + break; + + } + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function OpttablefuncelementlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opttablefuncelementlist; + return this; +} + +OpttablefuncelementlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +OpttablefuncelementlistContext.prototype.constructor = OpttablefuncelementlistContext; + +OpttablefuncelementlistContext.prototype.tablefuncelementlist = function() { + return this.getTypedRuleContext(TablefuncelementlistContext,0); +}; + +OpttablefuncelementlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpttablefuncelementlist(this); + } +}; + +OpttablefuncelementlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpttablefuncelementlist(this); + } +}; + +OpttablefuncelementlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpttablefuncelementlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.OpttablefuncelementlistContext = OpttablefuncelementlistContext; + +PostgreSQLParser.prototype.opttablefuncelementlist = function() { + + var localctx = new OpttablefuncelementlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 1088, PostgreSQLParser.RULE_opttablefuncelementlist); + try { + this.state = 8412; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 8410; + this.tablefuncelementlist(); + break; + case PostgreSQLParser.CLOSE_PAREN: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TablefuncelementlistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_tablefuncelementlist; + return this; +} + +TablefuncelementlistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TablefuncelementlistContext.prototype.constructor = TablefuncelementlistContext; + +TablefuncelementlistContext.prototype.tablefuncelement = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TablefuncelementContext); + } else { + return this.getTypedRuleContext(TablefuncelementContext,i); + } +}; + +TablefuncelementlistContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +TablefuncelementlistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTablefuncelementlist(this); + } +}; + +TablefuncelementlistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTablefuncelementlist(this); + } +}; + +TablefuncelementlistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTablefuncelementlist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TablefuncelementlistContext = TablefuncelementlistContext; + +PostgreSQLParser.prototype.tablefuncelementlist = function() { + + var localctx = new TablefuncelementlistContext(this, this._ctx, this.state); + this.enterRule(localctx, 1090, PostgreSQLParser.RULE_tablefuncelementlist); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8414; + this.tablefuncelement(); + this.state = 8419; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 8415; + this.match(PostgreSQLParser.COMMA); + this.state = 8416; + this.tablefuncelement(); + this.state = 8421; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TablefuncelementContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_tablefuncelement; + return this; +} + +TablefuncelementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TablefuncelementContext.prototype.constructor = TablefuncelementContext; + +TablefuncelementContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +TablefuncelementContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +TablefuncelementContext.prototype.opt_collate_clause = function() { + return this.getTypedRuleContext(Opt_collate_clauseContext,0); +}; + +TablefuncelementContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTablefuncelement(this); + } +}; + +TablefuncelementContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTablefuncelement(this); + } +}; + +TablefuncelementContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTablefuncelement(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TablefuncelementContext = TablefuncelementContext; + +PostgreSQLParser.prototype.tablefuncelement = function() { + + var localctx = new TablefuncelementContext(this, this._ctx, this.state); + this.enterRule(localctx, 1092, PostgreSQLParser.RULE_tablefuncelement); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8422; + this.colid(); + this.state = 8423; + this.typename(); + this.state = 8424; + this.opt_collate_clause(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function XmltableContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xmltable; + return this; +} + +XmltableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +XmltableContext.prototype.constructor = XmltableContext; + +XmltableContext.prototype.XMLTABLE = function() { + return this.getToken(PostgreSQLParser.XMLTABLE, 0); +}; + +XmltableContext.prototype.OPEN_PAREN = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.OPEN_PAREN); + } else { + return this.getToken(PostgreSQLParser.OPEN_PAREN, i); + } +}; + + +XmltableContext.prototype.CLOSE_PAREN = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.CLOSE_PAREN); + } else { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, i); + } +}; + + +XmltableContext.prototype.c_expr = function() { + return this.getTypedRuleContext(C_exprContext,0); +}; + +XmltableContext.prototype.xmlexists_argument = function() { + return this.getTypedRuleContext(Xmlexists_argumentContext,0); +}; + +XmltableContext.prototype.COLUMNS = function() { + return this.getToken(PostgreSQLParser.COLUMNS, 0); +}; + +XmltableContext.prototype.xmltable_column_list = function() { + return this.getTypedRuleContext(Xmltable_column_listContext,0); +}; + +XmltableContext.prototype.XMLNAMESPACES = function() { + return this.getToken(PostgreSQLParser.XMLNAMESPACES, 0); +}; + +XmltableContext.prototype.xml_namespace_list = function() { + return this.getTypedRuleContext(Xml_namespace_listContext,0); +}; + +XmltableContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +XmltableContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXmltable(this); + } +}; + +XmltableContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXmltable(this); + } +}; + +XmltableContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXmltable(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.XmltableContext = XmltableContext; + +PostgreSQLParser.prototype.xmltable = function() { + + var localctx = new XmltableContext(this, this._ctx, this.state); + this.enterRule(localctx, 1094, PostgreSQLParser.RULE_xmltable); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8426; + this.match(PostgreSQLParser.XMLTABLE); + this.state = 8427; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8443; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,488,this._ctx); + switch(la_) { + case 1: + this.state = 8428; + this.c_expr(); + this.state = 8429; + this.xmlexists_argument(); + this.state = 8430; + this.match(PostgreSQLParser.COLUMNS); + this.state = 8431; + this.xmltable_column_list(); + break; + + case 2: + this.state = 8433; + this.match(PostgreSQLParser.XMLNAMESPACES); + this.state = 8434; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8435; + this.xml_namespace_list(); + this.state = 8436; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 8437; + this.match(PostgreSQLParser.COMMA); + this.state = 8438; + this.c_expr(); + this.state = 8439; + this.xmlexists_argument(); + this.state = 8440; + this.match(PostgreSQLParser.COLUMNS); + this.state = 8441; + this.xmltable_column_list(); + break; + + } + this.state = 8445; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xmltable_column_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xmltable_column_list; + return this; +} + +Xmltable_column_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xmltable_column_listContext.prototype.constructor = Xmltable_column_listContext; + +Xmltable_column_listContext.prototype.xmltable_column_el = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Xmltable_column_elContext); + } else { + return this.getTypedRuleContext(Xmltable_column_elContext,i); + } +}; + +Xmltable_column_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Xmltable_column_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXmltable_column_list(this); + } +}; + +Xmltable_column_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXmltable_column_list(this); + } +}; + +Xmltable_column_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXmltable_column_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xmltable_column_listContext = Xmltable_column_listContext; + +PostgreSQLParser.prototype.xmltable_column_list = function() { + + var localctx = new Xmltable_column_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1096, PostgreSQLParser.RULE_xmltable_column_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8447; + this.xmltable_column_el(); + this.state = 8452; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 8448; + this.match(PostgreSQLParser.COMMA); + this.state = 8449; + this.xmltable_column_el(); + this.state = 8454; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xmltable_column_elContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xmltable_column_el; + return this; +} + +Xmltable_column_elContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xmltable_column_elContext.prototype.constructor = Xmltable_column_elContext; + +Xmltable_column_elContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Xmltable_column_elContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +Xmltable_column_elContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Xmltable_column_elContext.prototype.ORDINALITY = function() { + return this.getToken(PostgreSQLParser.ORDINALITY, 0); +}; + +Xmltable_column_elContext.prototype.xmltable_column_option_list = function() { + return this.getTypedRuleContext(Xmltable_column_option_listContext,0); +}; + +Xmltable_column_elContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXmltable_column_el(this); + } +}; + +Xmltable_column_elContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXmltable_column_el(this); + } +}; + +Xmltable_column_elContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXmltable_column_el(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xmltable_column_elContext = Xmltable_column_elContext; + +PostgreSQLParser.prototype.xmltable_column_el = function() { + + var localctx = new Xmltable_column_elContext(this, this._ctx, this.state); + this.enterRule(localctx, 1098, PostgreSQLParser.RULE_xmltable_column_el); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8455; + this.colid(); + this.state = 8462; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.state = 8456; + this.typename(); + this.state = 8458; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(((((_la - 33)) & ~0x1f) == 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.AND - 33)) | (1 << (PostgreSQLParser.ARRAY - 33)) | (1 << (PostgreSQLParser.COLLATE - 33)) | (1 << (PostgreSQLParser.COLUMN - 33)) | (1 << (PostgreSQLParser.CONSTRAINT - 33)) | (1 << (PostgreSQLParser.DEFAULT - 33)) | (1 << (PostgreSQLParser.DO - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || ((((_la - 77)) & ~0x1f) == 0 && ((1 << (_la - 77)) & ((1 << (PostgreSQLParser.NOT - 77)) | (1 << (PostgreSQLParser.NULL_P - 77)) | (1 << (PostgreSQLParser.TABLE - 77)))) !== 0) || ((((_la - 116)) & ~0x1f) == 0 && ((1 << (_la - 116)) & ((1 << (PostgreSQLParser.IS - 116)) | (1 << (PostgreSQLParser.OUTER_P - 116)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 116)) | (1 << (PostgreSQLParser.BACKWARD - 116)))) !== 0) || ((((_la - 153)) & ~0x1f) == 0 && ((1 << (_la - 153)) & ((1 << (PostgreSQLParser.CHAIN - 153)) | (1 << (PostgreSQLParser.CLOSE - 153)) | (1 << (PostgreSQLParser.COMMIT - 153)) | (1 << (PostgreSQLParser.CONTINUE_P - 153)) | (1 << (PostgreSQLParser.CURSOR - 153)))) !== 0) || ((((_la - 207)) & ~0x1f) == 0 && ((1 << (_la - 207)) & ((1 << (PostgreSQLParser.FIRST_P - 207)) | (1 << (PostgreSQLParser.FORWARD - 207)) | (1 << (PostgreSQLParser.INSERT - 207)))) !== 0) || ((((_la - 240)) & ~0x1f) == 0 && ((1 << (_la - 240)) & ((1 << (PostgreSQLParser.LAST_P - 240)) | (1 << (PostgreSQLParser.MOVE - 240)) | (1 << (PostgreSQLParser.NEXT - 240)) | (1 << (PostgreSQLParser.NO - 240)) | (1 << (PostgreSQLParser.OPTION - 240)))) !== 0) || ((((_la - 284)) & ~0x1f) == 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.PRIOR - 284)) | (1 << (PostgreSQLParser.RELATIVE_P - 284)) | (1 << (PostgreSQLParser.RESET - 284)) | (1 << (PostgreSQLParser.ROLLBACK - 284)) | (1 << (PostgreSQLParser.SCHEMA - 284)) | (1 << (PostgreSQLParser.SCROLL - 284)))) !== 0) || _la===PostgreSQLParser.SET || _la===PostgreSQLParser.TYPE_P || _la===PostgreSQLParser.CALL || _la===PostgreSQLParser.CURRENT_P || ((((_la - 468)) & ~0x1f) == 0 && ((1 << (_la - 468)) & ((1 << (PostgreSQLParser.ROWTYPE - 468)) | (1 << (PostgreSQLParser.DUMP - 468)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 468)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 468)) | (1 << (PostgreSQLParser.ERROR - 468)) | (1 << (PostgreSQLParser.USE_VARIABLE - 468)) | (1 << (PostgreSQLParser.USE_COLUMN - 468)) | (1 << (PostgreSQLParser.ALIAS - 468)) | (1 << (PostgreSQLParser.CONSTANT - 468)) | (1 << (PostgreSQLParser.PERFORM - 468)) | (1 << (PostgreSQLParser.GET - 468)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 468)) | (1 << (PostgreSQLParser.STACKED - 468)) | (1 << (PostgreSQLParser.ELSIF - 468)) | (1 << (PostgreSQLParser.REVERSE - 468)) | (1 << (PostgreSQLParser.SLICE - 468)) | (1 << (PostgreSQLParser.EXIT - 468)) | (1 << (PostgreSQLParser.RETURN - 468)))) !== 0) || ((((_la - 500)) & ~0x1f) == 0 && ((1 << (_la - 500)) & ((1 << (PostgreSQLParser.QUERY - 500)) | (1 << (PostgreSQLParser.RAISE - 500)) | (1 << (PostgreSQLParser.SQLSTATE - 500)) | (1 << (PostgreSQLParser.DEBUG - 500)) | (1 << (PostgreSQLParser.LOG - 500)) | (1 << (PostgreSQLParser.INFO - 500)) | (1 << (PostgreSQLParser.NOTICE - 500)) | (1 << (PostgreSQLParser.WARNING - 500)) | (1 << (PostgreSQLParser.EXCEPTION - 500)) | (1 << (PostgreSQLParser.ASSERT - 500)) | (1 << (PostgreSQLParser.OPEN - 500)) | (1 << (PostgreSQLParser.Identifier - 500)) | (1 << (PostgreSQLParser.QuotedIdentifier - 500)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 500)))) !== 0) || _la===PostgreSQLParser.PLSQLVARIABLENAME || _la===PostgreSQLParser.PLSQLIDENTIFIER) { + this.state = 8457; + this.xmltable_column_option_list(); + } + + break; + case PostgreSQLParser.FOR: + this.state = 8460; + this.match(PostgreSQLParser.FOR); + this.state = 8461; + this.match(PostgreSQLParser.ORDINALITY); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xmltable_column_option_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xmltable_column_option_list; + return this; +} + +Xmltable_column_option_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xmltable_column_option_listContext.prototype.constructor = Xmltable_column_option_listContext; + +Xmltable_column_option_listContext.prototype.xmltable_column_option_el = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Xmltable_column_option_elContext); + } else { + return this.getTypedRuleContext(Xmltable_column_option_elContext,i); + } +}; + +Xmltable_column_option_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXmltable_column_option_list(this); + } +}; + +Xmltable_column_option_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXmltable_column_option_list(this); + } +}; + +Xmltable_column_option_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXmltable_column_option_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xmltable_column_option_listContext = Xmltable_column_option_listContext; + +PostgreSQLParser.prototype.xmltable_column_option_list = function() { + + var localctx = new Xmltable_column_option_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1100, PostgreSQLParser.RULE_xmltable_column_option_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8465; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + this.state = 8464; + this.xmltable_column_option_el(); + this.state = 8467; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while(((((_la - 33)) & ~0x1f) == 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.AND - 33)) | (1 << (PostgreSQLParser.ARRAY - 33)) | (1 << (PostgreSQLParser.COLLATE - 33)) | (1 << (PostgreSQLParser.COLUMN - 33)) | (1 << (PostgreSQLParser.CONSTRAINT - 33)) | (1 << (PostgreSQLParser.DEFAULT - 33)) | (1 << (PostgreSQLParser.DO - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || ((((_la - 77)) & ~0x1f) == 0 && ((1 << (_la - 77)) & ((1 << (PostgreSQLParser.NOT - 77)) | (1 << (PostgreSQLParser.NULL_P - 77)) | (1 << (PostgreSQLParser.TABLE - 77)))) !== 0) || ((((_la - 116)) & ~0x1f) == 0 && ((1 << (_la - 116)) & ((1 << (PostgreSQLParser.IS - 116)) | (1 << (PostgreSQLParser.OUTER_P - 116)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 116)) | (1 << (PostgreSQLParser.BACKWARD - 116)))) !== 0) || ((((_la - 153)) & ~0x1f) == 0 && ((1 << (_la - 153)) & ((1 << (PostgreSQLParser.CHAIN - 153)) | (1 << (PostgreSQLParser.CLOSE - 153)) | (1 << (PostgreSQLParser.COMMIT - 153)) | (1 << (PostgreSQLParser.CONTINUE_P - 153)) | (1 << (PostgreSQLParser.CURSOR - 153)))) !== 0) || ((((_la - 207)) & ~0x1f) == 0 && ((1 << (_la - 207)) & ((1 << (PostgreSQLParser.FIRST_P - 207)) | (1 << (PostgreSQLParser.FORWARD - 207)) | (1 << (PostgreSQLParser.INSERT - 207)))) !== 0) || ((((_la - 240)) & ~0x1f) == 0 && ((1 << (_la - 240)) & ((1 << (PostgreSQLParser.LAST_P - 240)) | (1 << (PostgreSQLParser.MOVE - 240)) | (1 << (PostgreSQLParser.NEXT - 240)) | (1 << (PostgreSQLParser.NO - 240)) | (1 << (PostgreSQLParser.OPTION - 240)))) !== 0) || ((((_la - 284)) & ~0x1f) == 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.PRIOR - 284)) | (1 << (PostgreSQLParser.RELATIVE_P - 284)) | (1 << (PostgreSQLParser.RESET - 284)) | (1 << (PostgreSQLParser.ROLLBACK - 284)) | (1 << (PostgreSQLParser.SCHEMA - 284)) | (1 << (PostgreSQLParser.SCROLL - 284)))) !== 0) || _la===PostgreSQLParser.SET || _la===PostgreSQLParser.TYPE_P || _la===PostgreSQLParser.CALL || _la===PostgreSQLParser.CURRENT_P || ((((_la - 468)) & ~0x1f) == 0 && ((1 << (_la - 468)) & ((1 << (PostgreSQLParser.ROWTYPE - 468)) | (1 << (PostgreSQLParser.DUMP - 468)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 468)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 468)) | (1 << (PostgreSQLParser.ERROR - 468)) | (1 << (PostgreSQLParser.USE_VARIABLE - 468)) | (1 << (PostgreSQLParser.USE_COLUMN - 468)) | (1 << (PostgreSQLParser.ALIAS - 468)) | (1 << (PostgreSQLParser.CONSTANT - 468)) | (1 << (PostgreSQLParser.PERFORM - 468)) | (1 << (PostgreSQLParser.GET - 468)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 468)) | (1 << (PostgreSQLParser.STACKED - 468)) | (1 << (PostgreSQLParser.ELSIF - 468)) | (1 << (PostgreSQLParser.REVERSE - 468)) | (1 << (PostgreSQLParser.SLICE - 468)) | (1 << (PostgreSQLParser.EXIT - 468)) | (1 << (PostgreSQLParser.RETURN - 468)))) !== 0) || ((((_la - 500)) & ~0x1f) == 0 && ((1 << (_la - 500)) & ((1 << (PostgreSQLParser.QUERY - 500)) | (1 << (PostgreSQLParser.RAISE - 500)) | (1 << (PostgreSQLParser.SQLSTATE - 500)) | (1 << (PostgreSQLParser.DEBUG - 500)) | (1 << (PostgreSQLParser.LOG - 500)) | (1 << (PostgreSQLParser.INFO - 500)) | (1 << (PostgreSQLParser.NOTICE - 500)) | (1 << (PostgreSQLParser.WARNING - 500)) | (1 << (PostgreSQLParser.EXCEPTION - 500)) | (1 << (PostgreSQLParser.ASSERT - 500)) | (1 << (PostgreSQLParser.OPEN - 500)) | (1 << (PostgreSQLParser.Identifier - 500)) | (1 << (PostgreSQLParser.QuotedIdentifier - 500)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 500)))) !== 0) || _la===PostgreSQLParser.PLSQLVARIABLENAME || _la===PostgreSQLParser.PLSQLIDENTIFIER); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xmltable_column_option_elContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xmltable_column_option_el; + return this; +} + +Xmltable_column_option_elContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xmltable_column_option_elContext.prototype.constructor = Xmltable_column_option_elContext; + +Xmltable_column_option_elContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Xmltable_column_option_elContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Xmltable_column_option_elContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +Xmltable_column_option_elContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +Xmltable_column_option_elContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +Xmltable_column_option_elContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXmltable_column_option_el(this); + } +}; + +Xmltable_column_option_elContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXmltable_column_option_el(this); + } +}; + +Xmltable_column_option_elContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXmltable_column_option_el(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xmltable_column_option_elContext = Xmltable_column_option_elContext; + +PostgreSQLParser.prototype.xmltable_column_option_el = function() { + + var localctx = new Xmltable_column_option_elContext(this, this._ctx, this.state); + this.enterRule(localctx, 1102, PostgreSQLParser.RULE_xmltable_column_option_el); + try { + this.state = 8477; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,493,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8469; + this.match(PostgreSQLParser.DEFAULT); + this.state = 8470; + this.a_expr(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8471; + this.identifier(); + this.state = 8472; + this.a_expr(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 8474; + this.match(PostgreSQLParser.NOT); + this.state = 8475; + this.match(PostgreSQLParser.NULL_P); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 8476; + this.match(PostgreSQLParser.NULL_P); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xml_namespace_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xml_namespace_list; + return this; +} + +Xml_namespace_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xml_namespace_listContext.prototype.constructor = Xml_namespace_listContext; + +Xml_namespace_listContext.prototype.xml_namespace_el = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Xml_namespace_elContext); + } else { + return this.getTypedRuleContext(Xml_namespace_elContext,i); + } +}; + +Xml_namespace_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Xml_namespace_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXml_namespace_list(this); + } +}; + +Xml_namespace_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXml_namespace_list(this); + } +}; + +Xml_namespace_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXml_namespace_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xml_namespace_listContext = Xml_namespace_listContext; + +PostgreSQLParser.prototype.xml_namespace_list = function() { + + var localctx = new Xml_namespace_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1104, PostgreSQLParser.RULE_xml_namespace_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8479; + this.xml_namespace_el(); + this.state = 8484; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 8480; + this.match(PostgreSQLParser.COMMA); + this.state = 8481; + this.xml_namespace_el(); + this.state = 8486; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xml_namespace_elContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xml_namespace_el; + return this; +} + +Xml_namespace_elContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xml_namespace_elContext.prototype.constructor = Xml_namespace_elContext; + +Xml_namespace_elContext.prototype.b_expr = function() { + return this.getTypedRuleContext(B_exprContext,0); +}; + +Xml_namespace_elContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Xml_namespace_elContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +Xml_namespace_elContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Xml_namespace_elContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXml_namespace_el(this); + } +}; + +Xml_namespace_elContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXml_namespace_el(this); + } +}; + +Xml_namespace_elContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXml_namespace_el(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xml_namespace_elContext = Xml_namespace_elContext; + +PostgreSQLParser.prototype.xml_namespace_el = function() { + + var localctx = new Xml_namespace_elContext(this, this._ctx, this.state); + this.enterRule(localctx, 1106, PostgreSQLParser.RULE_xml_namespace_el); + try { + this.state = 8493; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,495,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8487; + this.b_expr(0); + this.state = 8488; + this.match(PostgreSQLParser.AS); + this.state = 8489; + this.collabel(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8491; + this.match(PostgreSQLParser.DEFAULT); + this.state = 8492; + this.b_expr(0); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function TypenameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_typename; + return this; +} + +TypenameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +TypenameContext.prototype.constructor = TypenameContext; + +TypenameContext.prototype.simpletypename = function() { + return this.getTypedRuleContext(SimpletypenameContext,0); +}; + +TypenameContext.prototype.opt_array_bounds = function() { + return this.getTypedRuleContext(Opt_array_boundsContext,0); +}; + +TypenameContext.prototype.ARRAY = function() { + return this.getToken(PostgreSQLParser.ARRAY, 0); +}; + +TypenameContext.prototype.SETOF = function() { + return this.getToken(PostgreSQLParser.SETOF, 0); +}; + +TypenameContext.prototype.OPEN_BRACKET = function() { + return this.getToken(PostgreSQLParser.OPEN_BRACKET, 0); +}; + +TypenameContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +TypenameContext.prototype.CLOSE_BRACKET = function() { + return this.getToken(PostgreSQLParser.CLOSE_BRACKET, 0); +}; + +TypenameContext.prototype.qualified_name = function() { + return this.getTypedRuleContext(Qualified_nameContext,0); +}; + +TypenameContext.prototype.PERCENT = function() { + return this.getToken(PostgreSQLParser.PERCENT, 0); +}; + +TypenameContext.prototype.ROWTYPE = function() { + return this.getToken(PostgreSQLParser.ROWTYPE, 0); +}; + +TypenameContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +TypenameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTypename(this); + } +}; + +TypenameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTypename(this); + } +}; + +TypenameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTypename(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.TypenameContext = TypenameContext; + +PostgreSQLParser.prototype.typename = function() { + + var localctx = new TypenameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1108, PostgreSQLParser.RULE_typename); + var _la = 0; // Token type + try { + this.state = 8513; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,499,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8496; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.SETOF) { + this.state = 8495; + this.match(PostgreSQLParser.SETOF); + } + + this.state = 8498; + this.simpletypename(); + this.state = 8507; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,498,this._ctx); + switch(la_) { + case 1: + this.state = 8499; + this.opt_array_bounds(); + break; + + case 2: + this.state = 8500; + this.match(PostgreSQLParser.ARRAY); + this.state = 8505; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,497,this._ctx); + if(la_===1) { + this.state = 8501; + this.match(PostgreSQLParser.OPEN_BRACKET); + this.state = 8502; + this.iconst(); + this.state = 8503; + this.match(PostgreSQLParser.CLOSE_BRACKET); + + } + break; + + } + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8509; + this.qualified_name(); + this.state = 8510; + this.match(PostgreSQLParser.PERCENT); + this.state = 8511; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.TYPE_P || _la===PostgreSQLParser.ROWTYPE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_array_boundsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_array_bounds; + return this; +} + +Opt_array_boundsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_array_boundsContext.prototype.constructor = Opt_array_boundsContext; + +Opt_array_boundsContext.prototype.OPEN_BRACKET = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.OPEN_BRACKET); + } else { + return this.getToken(PostgreSQLParser.OPEN_BRACKET, i); + } +}; + + +Opt_array_boundsContext.prototype.CLOSE_BRACKET = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.CLOSE_BRACKET); + } else { + return this.getToken(PostgreSQLParser.CLOSE_BRACKET, i); + } +}; + + +Opt_array_boundsContext.prototype.iconst = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(IconstContext); + } else { + return this.getTypedRuleContext(IconstContext,i); + } +}; + +Opt_array_boundsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_array_bounds(this); + } +}; + +Opt_array_boundsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_array_bounds(this); + } +}; + +Opt_array_boundsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_array_bounds(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_array_boundsContext = Opt_array_boundsContext; + +PostgreSQLParser.prototype.opt_array_bounds = function() { + + var localctx = new Opt_array_boundsContext(this, this._ctx, this.state); + this.enterRule(localctx, 1110, PostgreSQLParser.RULE_opt_array_bounds); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8522; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,501,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 8515; + this.match(PostgreSQLParser.OPEN_BRACKET); + this.state = 8517; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.Integral) { + this.state = 8516; + this.iconst(); + } + + this.state = 8519; + this.match(PostgreSQLParser.CLOSE_BRACKET); + } + this.state = 8524; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,501,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function SimpletypenameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_simpletypename; + return this; +} + +SimpletypenameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +SimpletypenameContext.prototype.constructor = SimpletypenameContext; + +SimpletypenameContext.prototype.generictype = function() { + return this.getTypedRuleContext(GenerictypeContext,0); +}; + +SimpletypenameContext.prototype.numeric = function() { + return this.getTypedRuleContext(NumericContext,0); +}; + +SimpletypenameContext.prototype.bit = function() { + return this.getTypedRuleContext(BitContext,0); +}; + +SimpletypenameContext.prototype.character = function() { + return this.getTypedRuleContext(CharacterContext,0); +}; + +SimpletypenameContext.prototype.constdatetime = function() { + return this.getTypedRuleContext(ConstdatetimeContext,0); +}; + +SimpletypenameContext.prototype.constinterval = function() { + return this.getTypedRuleContext(ConstintervalContext,0); +}; + +SimpletypenameContext.prototype.opt_interval = function() { + return this.getTypedRuleContext(Opt_intervalContext,0); +}; + +SimpletypenameContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +SimpletypenameContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +SimpletypenameContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +SimpletypenameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSimpletypename(this); + } +}; + +SimpletypenameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSimpletypename(this); + } +}; + +SimpletypenameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSimpletypename(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.SimpletypenameContext = SimpletypenameContext; + +PostgreSQLParser.prototype.simpletypename = function() { + + var localctx = new SimpletypenameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1112, PostgreSQLParser.RULE_simpletypename); + try { + this.state = 8538; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,503,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8525; + this.generictype(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8526; + this.numeric(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 8527; + this.bit(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 8528; + this.character(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 8529; + this.constdatetime(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 8530; + this.constinterval(); + this.state = 8536; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,502,this._ctx); + switch(la_) { + case 1: + this.state = 8531; + this.opt_interval(); + break; + + case 2: + this.state = 8532; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8533; + this.iconst(); + this.state = 8534; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ConsttypenameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_consttypename; + return this; +} + +ConsttypenameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ConsttypenameContext.prototype.constructor = ConsttypenameContext; + +ConsttypenameContext.prototype.numeric = function() { + return this.getTypedRuleContext(NumericContext,0); +}; + +ConsttypenameContext.prototype.constbit = function() { + return this.getTypedRuleContext(ConstbitContext,0); +}; + +ConsttypenameContext.prototype.constcharacter = function() { + return this.getTypedRuleContext(ConstcharacterContext,0); +}; + +ConsttypenameContext.prototype.constdatetime = function() { + return this.getTypedRuleContext(ConstdatetimeContext,0); +}; + +ConsttypenameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConsttypename(this); + } +}; + +ConsttypenameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConsttypename(this); + } +}; + +ConsttypenameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConsttypename(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ConsttypenameContext = ConsttypenameContext; + +PostgreSQLParser.prototype.consttypename = function() { + + var localctx = new ConsttypenameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1114, PostgreSQLParser.RULE_consttypename); + try { + this.state = 8544; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.REAL: + case PostgreSQLParser.SMALLINT: + this.enterOuterAlt(localctx, 1); + this.state = 8540; + this.numeric(); + break; + case PostgreSQLParser.BIT: + this.enterOuterAlt(localctx, 2); + this.state = 8541; + this.constbit(); + break; + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.VARCHAR: + this.enterOuterAlt(localctx, 3); + this.state = 8542; + this.constcharacter(); + break; + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + this.enterOuterAlt(localctx, 4); + this.state = 8543; + this.constdatetime(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function GenerictypeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_generictype; + return this; +} + +GenerictypeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +GenerictypeContext.prototype.constructor = GenerictypeContext; + +GenerictypeContext.prototype.type_function_name = function() { + return this.getTypedRuleContext(Type_function_nameContext,0); +}; + +GenerictypeContext.prototype.opt_type_modifiers = function() { + return this.getTypedRuleContext(Opt_type_modifiersContext,0); +}; + +GenerictypeContext.prototype.attrs = function() { + return this.getTypedRuleContext(AttrsContext,0); +}; + +GenerictypeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGenerictype(this); + } +}; + +GenerictypeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGenerictype(this); + } +}; + +GenerictypeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGenerictype(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.GenerictypeContext = GenerictypeContext; + +PostgreSQLParser.prototype.generictype = function() { + + var localctx = new GenerictypeContext(this, this._ctx, this.state); + this.enterRule(localctx, 1116, PostgreSQLParser.RULE_generictype); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8546; + this.type_function_name(); + this.state = 8548; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,505,this._ctx); + if(la_===1) { + this.state = 8547; + this.attrs(); + + } + this.state = 8550; + this.opt_type_modifiers(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_type_modifiersContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_type_modifiers; + return this; +} + +Opt_type_modifiersContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_type_modifiersContext.prototype.constructor = Opt_type_modifiersContext; + +Opt_type_modifiersContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opt_type_modifiersContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Opt_type_modifiersContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opt_type_modifiersContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_type_modifiers(this); + } +}; + +Opt_type_modifiersContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_type_modifiers(this); + } +}; + +Opt_type_modifiersContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_type_modifiers(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_type_modifiersContext = Opt_type_modifiersContext; + +PostgreSQLParser.prototype.opt_type_modifiers = function() { + + var localctx = new Opt_type_modifiersContext(this, this._ctx, this.state); + this.enterRule(localctx, 1118, PostgreSQLParser.RULE_opt_type_modifiers); + try { + this.state = 8557; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,506,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8552; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8553; + this.expr_list(); + this.state = 8554; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function NumericContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_numeric; + return this; +} + +NumericContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +NumericContext.prototype.constructor = NumericContext; + +NumericContext.prototype.INT_P = function() { + return this.getToken(PostgreSQLParser.INT_P, 0); +}; + +NumericContext.prototype.INTEGER = function() { + return this.getToken(PostgreSQLParser.INTEGER, 0); +}; + +NumericContext.prototype.SMALLINT = function() { + return this.getToken(PostgreSQLParser.SMALLINT, 0); +}; + +NumericContext.prototype.BIGINT = function() { + return this.getToken(PostgreSQLParser.BIGINT, 0); +}; + +NumericContext.prototype.REAL = function() { + return this.getToken(PostgreSQLParser.REAL, 0); +}; + +NumericContext.prototype.FLOAT_P = function() { + return this.getToken(PostgreSQLParser.FLOAT_P, 0); +}; + +NumericContext.prototype.opt_float = function() { + return this.getTypedRuleContext(Opt_floatContext,0); +}; + +NumericContext.prototype.DOUBLE_P = function() { + return this.getToken(PostgreSQLParser.DOUBLE_P, 0); +}; + +NumericContext.prototype.PRECISION = function() { + return this.getToken(PostgreSQLParser.PRECISION, 0); +}; + +NumericContext.prototype.DECIMAL_P = function() { + return this.getToken(PostgreSQLParser.DECIMAL_P, 0); +}; + +NumericContext.prototype.opt_type_modifiers = function() { + return this.getTypedRuleContext(Opt_type_modifiersContext,0); +}; + +NumericContext.prototype.DEC = function() { + return this.getToken(PostgreSQLParser.DEC, 0); +}; + +NumericContext.prototype.NUMERIC = function() { + return this.getToken(PostgreSQLParser.NUMERIC, 0); +}; + +NumericContext.prototype.BOOLEAN_P = function() { + return this.getToken(PostgreSQLParser.BOOLEAN_P, 0); +}; + +NumericContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterNumeric(this); + } +}; + +NumericContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitNumeric(this); + } +}; + +NumericContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitNumeric(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.NumericContext = NumericContext; + +PostgreSQLParser.prototype.numeric = function() { + + var localctx = new NumericContext(this, this._ctx, this.state); + this.enterRule(localctx, 1120, PostgreSQLParser.RULE_numeric); + try { + this.state = 8575; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.INT_P: + this.enterOuterAlt(localctx, 1); + this.state = 8559; + this.match(PostgreSQLParser.INT_P); + break; + case PostgreSQLParser.INTEGER: + this.enterOuterAlt(localctx, 2); + this.state = 8560; + this.match(PostgreSQLParser.INTEGER); + break; + case PostgreSQLParser.SMALLINT: + this.enterOuterAlt(localctx, 3); + this.state = 8561; + this.match(PostgreSQLParser.SMALLINT); + break; + case PostgreSQLParser.BIGINT: + this.enterOuterAlt(localctx, 4); + this.state = 8562; + this.match(PostgreSQLParser.BIGINT); + break; + case PostgreSQLParser.REAL: + this.enterOuterAlt(localctx, 5); + this.state = 8563; + this.match(PostgreSQLParser.REAL); + break; + case PostgreSQLParser.FLOAT_P: + this.enterOuterAlt(localctx, 6); + this.state = 8564; + this.match(PostgreSQLParser.FLOAT_P); + this.state = 8565; + this.opt_float(); + break; + case PostgreSQLParser.DOUBLE_P: + this.enterOuterAlt(localctx, 7); + this.state = 8566; + this.match(PostgreSQLParser.DOUBLE_P); + this.state = 8567; + this.match(PostgreSQLParser.PRECISION); + break; + case PostgreSQLParser.DECIMAL_P: + this.enterOuterAlt(localctx, 8); + this.state = 8568; + this.match(PostgreSQLParser.DECIMAL_P); + this.state = 8569; + this.opt_type_modifiers(); + break; + case PostgreSQLParser.DEC: + this.enterOuterAlt(localctx, 9); + this.state = 8570; + this.match(PostgreSQLParser.DEC); + this.state = 8571; + this.opt_type_modifiers(); + break; + case PostgreSQLParser.NUMERIC: + this.enterOuterAlt(localctx, 10); + this.state = 8572; + this.match(PostgreSQLParser.NUMERIC); + this.state = 8573; + this.opt_type_modifiers(); + break; + case PostgreSQLParser.BOOLEAN_P: + this.enterOuterAlt(localctx, 11); + this.state = 8574; + this.match(PostgreSQLParser.BOOLEAN_P); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_floatContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_float; + return this; +} + +Opt_floatContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_floatContext.prototype.constructor = Opt_floatContext; + +Opt_floatContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opt_floatContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +Opt_floatContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opt_floatContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_float(this); + } +}; + +Opt_floatContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_float(this); + } +}; + +Opt_floatContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_float(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_floatContext = Opt_floatContext; + +PostgreSQLParser.prototype.opt_float = function() { + + var localctx = new Opt_floatContext(this, this._ctx, this.state); + this.enterRule(localctx, 1122, PostgreSQLParser.RULE_opt_float); + try { + this.state = 8582; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,508,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8577; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8578; + this.iconst(); + this.state = 8579; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function BitContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_bit; + return this; +} + +BitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +BitContext.prototype.constructor = BitContext; + +BitContext.prototype.bitwithlength = function() { + return this.getTypedRuleContext(BitwithlengthContext,0); +}; + +BitContext.prototype.bitwithoutlength = function() { + return this.getTypedRuleContext(BitwithoutlengthContext,0); +}; + +BitContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterBit(this); + } +}; + +BitContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitBit(this); + } +}; + +BitContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitBit(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.BitContext = BitContext; + +PostgreSQLParser.prototype.bit = function() { + + var localctx = new BitContext(this, this._ctx, this.state); + this.enterRule(localctx, 1124, PostgreSQLParser.RULE_bit); + try { + this.state = 8586; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,509,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8584; + this.bitwithlength(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8585; + this.bitwithoutlength(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ConstbitContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constbit; + return this; +} + +ConstbitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ConstbitContext.prototype.constructor = ConstbitContext; + +ConstbitContext.prototype.bitwithlength = function() { + return this.getTypedRuleContext(BitwithlengthContext,0); +}; + +ConstbitContext.prototype.bitwithoutlength = function() { + return this.getTypedRuleContext(BitwithoutlengthContext,0); +}; + +ConstbitContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstbit(this); + } +}; + +ConstbitContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstbit(this); + } +}; + +ConstbitContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstbit(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ConstbitContext = ConstbitContext; + +PostgreSQLParser.prototype.constbit = function() { + + var localctx = new ConstbitContext(this, this._ctx, this.state); + this.enterRule(localctx, 1126, PostgreSQLParser.RULE_constbit); + try { + this.state = 8590; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,510,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8588; + this.bitwithlength(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8589; + this.bitwithoutlength(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function BitwithlengthContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_bitwithlength; + return this; +} + +BitwithlengthContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +BitwithlengthContext.prototype.constructor = BitwithlengthContext; + +BitwithlengthContext.prototype.BIT = function() { + return this.getToken(PostgreSQLParser.BIT, 0); +}; + +BitwithlengthContext.prototype.opt_varying = function() { + return this.getTypedRuleContext(Opt_varyingContext,0); +}; + +BitwithlengthContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +BitwithlengthContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +BitwithlengthContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +BitwithlengthContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterBitwithlength(this); + } +}; + +BitwithlengthContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitBitwithlength(this); + } +}; + +BitwithlengthContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitBitwithlength(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.BitwithlengthContext = BitwithlengthContext; + +PostgreSQLParser.prototype.bitwithlength = function() { + + var localctx = new BitwithlengthContext(this, this._ctx, this.state); + this.enterRule(localctx, 1128, PostgreSQLParser.RULE_bitwithlength); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8592; + this.match(PostgreSQLParser.BIT); + this.state = 8593; + this.opt_varying(); + this.state = 8594; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8595; + this.expr_list(); + this.state = 8596; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function BitwithoutlengthContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_bitwithoutlength; + return this; +} + +BitwithoutlengthContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +BitwithoutlengthContext.prototype.constructor = BitwithoutlengthContext; + +BitwithoutlengthContext.prototype.BIT = function() { + return this.getToken(PostgreSQLParser.BIT, 0); +}; + +BitwithoutlengthContext.prototype.opt_varying = function() { + return this.getTypedRuleContext(Opt_varyingContext,0); +}; + +BitwithoutlengthContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterBitwithoutlength(this); + } +}; + +BitwithoutlengthContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitBitwithoutlength(this); + } +}; + +BitwithoutlengthContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitBitwithoutlength(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.BitwithoutlengthContext = BitwithoutlengthContext; + +PostgreSQLParser.prototype.bitwithoutlength = function() { + + var localctx = new BitwithoutlengthContext(this, this._ctx, this.state); + this.enterRule(localctx, 1130, PostgreSQLParser.RULE_bitwithoutlength); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8598; + this.match(PostgreSQLParser.BIT); + this.state = 8599; + this.opt_varying(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CharacterContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_character; + return this; +} + +CharacterContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CharacterContext.prototype.constructor = CharacterContext; + +CharacterContext.prototype.character_c = function() { + return this.getTypedRuleContext(Character_cContext,0); +}; + +CharacterContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +CharacterContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +CharacterContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +CharacterContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCharacter(this); + } +}; + +CharacterContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCharacter(this); + } +}; + +CharacterContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCharacter(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CharacterContext = CharacterContext; + +PostgreSQLParser.prototype.character = function() { + + var localctx = new CharacterContext(this, this._ctx, this.state); + this.enterRule(localctx, 1132, PostgreSQLParser.RULE_character); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8601; + this.character_c(); + this.state = 8606; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,511,this._ctx); + if(la_===1) { + this.state = 8602; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8603; + this.iconst(); + this.state = 8604; + this.match(PostgreSQLParser.CLOSE_PAREN); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ConstcharacterContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constcharacter; + return this; +} + +ConstcharacterContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ConstcharacterContext.prototype.constructor = ConstcharacterContext; + +ConstcharacterContext.prototype.character_c = function() { + return this.getTypedRuleContext(Character_cContext,0); +}; + +ConstcharacterContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +ConstcharacterContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +ConstcharacterContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +ConstcharacterContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstcharacter(this); + } +}; + +ConstcharacterContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstcharacter(this); + } +}; + +ConstcharacterContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstcharacter(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ConstcharacterContext = ConstcharacterContext; + +PostgreSQLParser.prototype.constcharacter = function() { + + var localctx = new ConstcharacterContext(this, this._ctx, this.state); + this.enterRule(localctx, 1134, PostgreSQLParser.RULE_constcharacter); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8608; + this.character_c(); + this.state = 8613; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OPEN_PAREN) { + this.state = 8609; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8610; + this.iconst(); + this.state = 8611; + this.match(PostgreSQLParser.CLOSE_PAREN); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Character_cContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_character_c; + return this; +} + +Character_cContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Character_cContext.prototype.constructor = Character_cContext; + +Character_cContext.prototype.opt_varying = function() { + return this.getTypedRuleContext(Opt_varyingContext,0); +}; + +Character_cContext.prototype.CHARACTER = function() { + return this.getToken(PostgreSQLParser.CHARACTER, 0); +}; + +Character_cContext.prototype.CHAR_P = function() { + return this.getToken(PostgreSQLParser.CHAR_P, 0); +}; + +Character_cContext.prototype.NCHAR = function() { + return this.getToken(PostgreSQLParser.NCHAR, 0); +}; + +Character_cContext.prototype.VARCHAR = function() { + return this.getToken(PostgreSQLParser.VARCHAR, 0); +}; + +Character_cContext.prototype.NATIONAL = function() { + return this.getToken(PostgreSQLParser.NATIONAL, 0); +}; + +Character_cContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCharacter_c(this); + } +}; + +Character_cContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCharacter_c(this); + } +}; + +Character_cContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCharacter_c(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Character_cContext = Character_cContext; + +PostgreSQLParser.prototype.character_c = function() { + + var localctx = new Character_cContext(this, this._ctx, this.state); + this.enterRule(localctx, 1136, PostgreSQLParser.RULE_character_c); + var _la = 0; // Token type + try { + this.state = 8621; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.NCHAR: + this.enterOuterAlt(localctx, 1); + this.state = 8615; + _la = this._input.LA(1); + if(!(((((_la - 382)) & ~0x1f) == 0 && ((1 << (_la - 382)) & ((1 << (PostgreSQLParser.CHAR_P - 382)) | (1 << (PostgreSQLParser.CHARACTER - 382)) | (1 << (PostgreSQLParser.NCHAR - 382)))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8616; + this.opt_varying(); + break; + case PostgreSQLParser.VARCHAR: + this.enterOuterAlt(localctx, 2); + this.state = 8617; + this.match(PostgreSQLParser.VARCHAR); + break; + case PostgreSQLParser.NATIONAL: + this.enterOuterAlt(localctx, 3); + this.state = 8618; + this.match(PostgreSQLParser.NATIONAL); + this.state = 8619; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.CHAR_P || _la===PostgreSQLParser.CHARACTER)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8620; + this.opt_varying(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_varyingContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_varying; + return this; +} + +Opt_varyingContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_varyingContext.prototype.constructor = Opt_varyingContext; + +Opt_varyingContext.prototype.VARYING = function() { + return this.getToken(PostgreSQLParser.VARYING, 0); +}; + +Opt_varyingContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_varying(this); + } +}; + +Opt_varyingContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_varying(this); + } +}; + +Opt_varyingContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_varying(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_varyingContext = Opt_varyingContext; + +PostgreSQLParser.prototype.opt_varying = function() { + + var localctx = new Opt_varyingContext(this, this._ctx, this.state); + this.enterRule(localctx, 1138, PostgreSQLParser.RULE_opt_varying); + try { + this.state = 8625; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,514,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8623; + this.match(PostgreSQLParser.VARYING); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ConstdatetimeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constdatetime; + return this; +} + +ConstdatetimeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ConstdatetimeContext.prototype.constructor = ConstdatetimeContext; + +ConstdatetimeContext.prototype.opt_timezone = function() { + return this.getTypedRuleContext(Opt_timezoneContext,0); +}; + +ConstdatetimeContext.prototype.TIMESTAMP = function() { + return this.getToken(PostgreSQLParser.TIMESTAMP, 0); +}; + +ConstdatetimeContext.prototype.TIME = function() { + return this.getToken(PostgreSQLParser.TIME, 0); +}; + +ConstdatetimeContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +ConstdatetimeContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +ConstdatetimeContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +ConstdatetimeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstdatetime(this); + } +}; + +ConstdatetimeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstdatetime(this); + } +}; + +ConstdatetimeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstdatetime(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ConstdatetimeContext = ConstdatetimeContext; + +PostgreSQLParser.prototype.constdatetime = function() { + + var localctx = new ConstdatetimeContext(this, this._ctx, this.state); + this.enterRule(localctx, 1140, PostgreSQLParser.RULE_constdatetime); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8627; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.TIME || _la===PostgreSQLParser.TIMESTAMP)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8632; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,515,this._ctx); + if(la_===1) { + this.state = 8628; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8629; + this.iconst(); + this.state = 8630; + this.match(PostgreSQLParser.CLOSE_PAREN); + + } + this.state = 8634; + this.opt_timezone(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ConstintervalContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_constinterval; + return this; +} + +ConstintervalContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ConstintervalContext.prototype.constructor = ConstintervalContext; + +ConstintervalContext.prototype.INTERVAL = function() { + return this.getToken(PostgreSQLParser.INTERVAL, 0); +}; + +ConstintervalContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterConstinterval(this); + } +}; + +ConstintervalContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitConstinterval(this); + } +}; + +ConstintervalContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitConstinterval(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ConstintervalContext = ConstintervalContext; + +PostgreSQLParser.prototype.constinterval = function() { + + var localctx = new ConstintervalContext(this, this._ctx, this.state); + this.enterRule(localctx, 1142, PostgreSQLParser.RULE_constinterval); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8636; + this.match(PostgreSQLParser.INTERVAL); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_timezoneContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_timezone; + return this; +} + +Opt_timezoneContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_timezoneContext.prototype.constructor = Opt_timezoneContext; + +Opt_timezoneContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Opt_timezoneContext.prototype.TIME = function() { + return this.getToken(PostgreSQLParser.TIME, 0); +}; + +Opt_timezoneContext.prototype.ZONE = function() { + return this.getToken(PostgreSQLParser.ZONE, 0); +}; + +Opt_timezoneContext.prototype.WITHOUT = function() { + return this.getToken(PostgreSQLParser.WITHOUT, 0); +}; + +Opt_timezoneContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_timezone(this); + } +}; + +Opt_timezoneContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_timezone(this); + } +}; + +Opt_timezoneContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_timezone(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_timezoneContext = Opt_timezoneContext; + +PostgreSQLParser.prototype.opt_timezone = function() { + + var localctx = new Opt_timezoneContext(this, this._ctx, this.state); + this.enterRule(localctx, 1144, PostgreSQLParser.RULE_opt_timezone); + try { + this.state = 8645; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,516,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8638; + this.match(PostgreSQLParser.WITH); + this.state = 8639; + this.match(PostgreSQLParser.TIME); + this.state = 8640; + this.match(PostgreSQLParser.ZONE); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8641; + this.match(PostgreSQLParser.WITHOUT); + this.state = 8642; + this.match(PostgreSQLParser.TIME); + this.state = 8643; + this.match(PostgreSQLParser.ZONE); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_intervalContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_interval; + return this; +} + +Opt_intervalContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_intervalContext.prototype.constructor = Opt_intervalContext; + +Opt_intervalContext.prototype.YEAR_P = function() { + return this.getToken(PostgreSQLParser.YEAR_P, 0); +}; + +Opt_intervalContext.prototype.MONTH_P = function() { + return this.getToken(PostgreSQLParser.MONTH_P, 0); +}; + +Opt_intervalContext.prototype.DAY_P = function() { + return this.getToken(PostgreSQLParser.DAY_P, 0); +}; + +Opt_intervalContext.prototype.HOUR_P = function() { + return this.getToken(PostgreSQLParser.HOUR_P, 0); +}; + +Opt_intervalContext.prototype.MINUTE_P = function() { + return this.getToken(PostgreSQLParser.MINUTE_P, 0); +}; + +Opt_intervalContext.prototype.interval_second = function() { + return this.getTypedRuleContext(Interval_secondContext,0); +}; + +Opt_intervalContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +Opt_intervalContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_interval(this); + } +}; + +Opt_intervalContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_interval(this); + } +}; + +Opt_intervalContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_interval(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_intervalContext = Opt_intervalContext; + +PostgreSQLParser.prototype.opt_interval = function() { + + var localctx = new Opt_intervalContext(this, this._ctx, this.state); + this.enterRule(localctx, 1146, PostgreSQLParser.RULE_opt_interval); + try { + this.state = 8673; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,519,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8647; + this.match(PostgreSQLParser.YEAR_P); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8648; + this.match(PostgreSQLParser.MONTH_P); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 8649; + this.match(PostgreSQLParser.DAY_P); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 8650; + this.match(PostgreSQLParser.HOUR_P); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 8651; + this.match(PostgreSQLParser.MINUTE_P); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 8652; + this.interval_second(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 8653; + this.match(PostgreSQLParser.YEAR_P); + this.state = 8654; + this.match(PostgreSQLParser.TO); + this.state = 8655; + this.match(PostgreSQLParser.MONTH_P); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 8656; + this.match(PostgreSQLParser.DAY_P); + this.state = 8657; + this.match(PostgreSQLParser.TO); + this.state = 8661; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.HOUR_P: + this.state = 8658; + this.match(PostgreSQLParser.HOUR_P); + break; + case PostgreSQLParser.MINUTE_P: + this.state = 8659; + this.match(PostgreSQLParser.MINUTE_P); + break; + case PostgreSQLParser.SECOND_P: + this.state = 8660; + this.interval_second(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 8663; + this.match(PostgreSQLParser.HOUR_P); + this.state = 8664; + this.match(PostgreSQLParser.TO); + this.state = 8667; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.MINUTE_P: + this.state = 8665; + this.match(PostgreSQLParser.MINUTE_P); + break; + case PostgreSQLParser.SECOND_P: + this.state = 8666; + this.interval_second(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 8669; + this.match(PostgreSQLParser.MINUTE_P); + this.state = 8670; + this.match(PostgreSQLParser.TO); + this.state = 8671; + this.interval_second(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Interval_secondContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_interval_second; + return this; +} + +Interval_secondContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Interval_secondContext.prototype.constructor = Interval_secondContext; + +Interval_secondContext.prototype.SECOND_P = function() { + return this.getToken(PostgreSQLParser.SECOND_P, 0); +}; + +Interval_secondContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Interval_secondContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +Interval_secondContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Interval_secondContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterInterval_second(this); + } +}; + +Interval_secondContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitInterval_second(this); + } +}; + +Interval_secondContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitInterval_second(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Interval_secondContext = Interval_secondContext; + +PostgreSQLParser.prototype.interval_second = function() { + + var localctx = new Interval_secondContext(this, this._ctx, this.state); + this.enterRule(localctx, 1148, PostgreSQLParser.RULE_interval_second); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8675; + this.match(PostgreSQLParser.SECOND_P); + this.state = 8680; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,520,this._ctx); + if(la_===1) { + this.state = 8676; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8677; + this.iconst(); + this.state = 8678; + this.match(PostgreSQLParser.CLOSE_PAREN); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_escapeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_escape; + return this; +} + +Opt_escapeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_escapeContext.prototype.constructor = Opt_escapeContext; + +Opt_escapeContext.prototype.ESCAPE = function() { + return this.getToken(PostgreSQLParser.ESCAPE, 0); +}; + +Opt_escapeContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Opt_escapeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_escape(this); + } +}; + +Opt_escapeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_escape(this); + } +}; + +Opt_escapeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_escape(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_escapeContext = Opt_escapeContext; + +PostgreSQLParser.prototype.opt_escape = function() { + + var localctx = new Opt_escapeContext(this, this._ctx, this.state); + this.enterRule(localctx, 1150, PostgreSQLParser.RULE_opt_escape); + try { + this.state = 8685; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,521,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8682; + this.match(PostgreSQLParser.ESCAPE); + this.state = 8683; + this.a_expr(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr; + return this; +} + +A_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_exprContext.prototype.constructor = A_exprContext; + +A_exprContext.prototype.a_expr_qual = function() { + return this.getTypedRuleContext(A_expr_qualContext,0); +}; + +A_exprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr(this); + } +}; + +A_exprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr(this); + } +}; + +A_exprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_exprContext = A_exprContext; + +PostgreSQLParser.prototype.a_expr = function() { + + var localctx = new A_exprContext(this, this._ctx, this.state); + this.enterRule(localctx, 1152, PostgreSQLParser.RULE_a_expr); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8687; + this.a_expr_qual(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_qualContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_qual; + return this; +} + +A_expr_qualContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_qualContext.prototype.constructor = A_expr_qualContext; + +A_expr_qualContext.prototype.a_expr_lessless = function() { + return this.getTypedRuleContext(A_expr_lesslessContext,0); +}; + +A_expr_qualContext.prototype.qual_op = function() { + return this.getTypedRuleContext(Qual_opContext,0); +}; + +A_expr_qualContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_qual(this); + } +}; + +A_expr_qualContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_qual(this); + } +}; + +A_expr_qualContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_qual(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_qualContext = A_expr_qualContext; + +PostgreSQLParser.prototype.a_expr_qual = function() { + + var localctx = new A_expr_qualContext(this, this._ctx, this.state); + this.enterRule(localctx, 1154, PostgreSQLParser.RULE_a_expr_qual); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8689; + this.a_expr_lessless(); + this.state = 8691; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,522,this._ctx); + if(la_===1) { + this.state = 8690; + this.qual_op(); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_lesslessContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_lessless; + return this; +} + +A_expr_lesslessContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_lesslessContext.prototype.constructor = A_expr_lesslessContext; + +A_expr_lesslessContext.prototype.a_expr_or = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_expr_orContext); + } else { + return this.getTypedRuleContext(A_expr_orContext,i); + } +}; + +A_expr_lesslessContext.prototype.LESS_LESS = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.LESS_LESS); + } else { + return this.getToken(PostgreSQLParser.LESS_LESS, i); + } +}; + + +A_expr_lesslessContext.prototype.GREATER_GREATER = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.GREATER_GREATER); + } else { + return this.getToken(PostgreSQLParser.GREATER_GREATER, i); + } +}; + + +A_expr_lesslessContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_lessless(this); + } +}; + +A_expr_lesslessContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_lessless(this); + } +}; + +A_expr_lesslessContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_lessless(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_lesslessContext = A_expr_lesslessContext; + +PostgreSQLParser.prototype.a_expr_lessless = function() { + + var localctx = new A_expr_lesslessContext(this, this._ctx, this.state); + this.enterRule(localctx, 1156, PostgreSQLParser.RULE_a_expr_lessless); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8693; + this.a_expr_or(); + this.state = 8698; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,523,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 8694; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.LESS_LESS || _la===PostgreSQLParser.GREATER_GREATER)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8695; + this.a_expr_or(); + } + this.state = 8700; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,523,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_orContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_or; + return this; +} + +A_expr_orContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_orContext.prototype.constructor = A_expr_orContext; + +A_expr_orContext.prototype.a_expr_and = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_expr_andContext); + } else { + return this.getTypedRuleContext(A_expr_andContext,i); + } +}; + +A_expr_orContext.prototype.OR = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.OR); + } else { + return this.getToken(PostgreSQLParser.OR, i); + } +}; + + +A_expr_orContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_or(this); + } +}; + +A_expr_orContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_or(this); + } +}; + +A_expr_orContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_or(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_orContext = A_expr_orContext; + +PostgreSQLParser.prototype.a_expr_or = function() { + + var localctx = new A_expr_orContext(this, this._ctx, this.state); + this.enterRule(localctx, 1158, PostgreSQLParser.RULE_a_expr_or); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8701; + this.a_expr_and(); + this.state = 8706; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,524,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 8702; + this.match(PostgreSQLParser.OR); + this.state = 8703; + this.a_expr_and(); + } + this.state = 8708; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,524,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_andContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_and; + return this; +} + +A_expr_andContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_andContext.prototype.constructor = A_expr_andContext; + +A_expr_andContext.prototype.a_expr_in = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_expr_inContext); + } else { + return this.getTypedRuleContext(A_expr_inContext,i); + } +}; + +A_expr_andContext.prototype.AND = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.AND); + } else { + return this.getToken(PostgreSQLParser.AND, i); + } +}; + + +A_expr_andContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_and(this); + } +}; + +A_expr_andContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_and(this); + } +}; + +A_expr_andContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_and(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_andContext = A_expr_andContext; + +PostgreSQLParser.prototype.a_expr_and = function() { + + var localctx = new A_expr_andContext(this, this._ctx, this.state); + this.enterRule(localctx, 1160, PostgreSQLParser.RULE_a_expr_and); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8709; + this.a_expr_in(); + this.state = 8714; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,525,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 8710; + this.match(PostgreSQLParser.AND); + this.state = 8711; + this.a_expr_in(); + } + this.state = 8716; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,525,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_inContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_in; + return this; +} + +A_expr_inContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_inContext.prototype.constructor = A_expr_inContext; + +A_expr_inContext.prototype.a_expr_unary_not = function() { + return this.getTypedRuleContext(A_expr_unary_notContext,0); +}; + +A_expr_inContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +A_expr_inContext.prototype.in_expr = function() { + return this.getTypedRuleContext(In_exprContext,0); +}; + +A_expr_inContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +A_expr_inContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_in(this); + } +}; + +A_expr_inContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_in(this); + } +}; + +A_expr_inContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_in(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_inContext = A_expr_inContext; + +PostgreSQLParser.prototype.a_expr_in = function() { + + var localctx = new A_expr_inContext(this, this._ctx, this.state); + this.enterRule(localctx, 1162, PostgreSQLParser.RULE_a_expr_in); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8717; + this.a_expr_unary_not(); + this.state = 8723; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,527,this._ctx); + if(la_===1) { + this.state = 8719; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.NOT) { + this.state = 8718; + this.match(PostgreSQLParser.NOT); + } + + this.state = 8721; + this.match(PostgreSQLParser.IN_P); + this.state = 8722; + this.in_expr(); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_unary_notContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_unary_not; + return this; +} + +A_expr_unary_notContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_unary_notContext.prototype.constructor = A_expr_unary_notContext; + +A_expr_unary_notContext.prototype.a_expr_isnull = function() { + return this.getTypedRuleContext(A_expr_isnullContext,0); +}; + +A_expr_unary_notContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +A_expr_unary_notContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_unary_not(this); + } +}; + +A_expr_unary_notContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_unary_not(this); + } +}; + +A_expr_unary_notContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_unary_not(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_unary_notContext = A_expr_unary_notContext; + +PostgreSQLParser.prototype.a_expr_unary_not = function() { + + var localctx = new A_expr_unary_notContext(this, this._ctx, this.state); + this.enterRule(localctx, 1164, PostgreSQLParser.RULE_a_expr_unary_not); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8726; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.NOT) { + this.state = 8725; + this.match(PostgreSQLParser.NOT); + } + + this.state = 8728; + this.a_expr_isnull(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_isnullContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_isnull; + return this; +} + +A_expr_isnullContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_isnullContext.prototype.constructor = A_expr_isnullContext; + +A_expr_isnullContext.prototype.a_expr_is_not = function() { + return this.getTypedRuleContext(A_expr_is_notContext,0); +}; + +A_expr_isnullContext.prototype.ISNULL = function() { + return this.getToken(PostgreSQLParser.ISNULL, 0); +}; + +A_expr_isnullContext.prototype.NOTNULL = function() { + return this.getToken(PostgreSQLParser.NOTNULL, 0); +}; + +A_expr_isnullContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_isnull(this); + } +}; + +A_expr_isnullContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_isnull(this); + } +}; + +A_expr_isnullContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_isnull(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_isnullContext = A_expr_isnullContext; + +PostgreSQLParser.prototype.a_expr_isnull = function() { + + var localctx = new A_expr_isnullContext(this, this._ctx, this.state); + this.enterRule(localctx, 1166, PostgreSQLParser.RULE_a_expr_isnull); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8730; + this.a_expr_is_not(); + this.state = 8732; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,529,this._ctx); + if(la_===1) { + this.state = 8731; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.ISNULL || _la===PostgreSQLParser.NOTNULL)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_is_notContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_is_not; + return this; +} + +A_expr_is_notContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_is_notContext.prototype.constructor = A_expr_is_notContext; + +A_expr_is_notContext.prototype.a_expr_compare = function() { + return this.getTypedRuleContext(A_expr_compareContext,0); +}; + +A_expr_is_notContext.prototype.IS = function() { + return this.getToken(PostgreSQLParser.IS, 0); +}; + +A_expr_is_notContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +A_expr_is_notContext.prototype.TRUE_P = function() { + return this.getToken(PostgreSQLParser.TRUE_P, 0); +}; + +A_expr_is_notContext.prototype.FALSE_P = function() { + return this.getToken(PostgreSQLParser.FALSE_P, 0); +}; + +A_expr_is_notContext.prototype.UNKNOWN = function() { + return this.getToken(PostgreSQLParser.UNKNOWN, 0); +}; + +A_expr_is_notContext.prototype.DISTINCT = function() { + return this.getToken(PostgreSQLParser.DISTINCT, 0); +}; + +A_expr_is_notContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +A_expr_is_notContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +A_expr_is_notContext.prototype.OF = function() { + return this.getToken(PostgreSQLParser.OF, 0); +}; + +A_expr_is_notContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +A_expr_is_notContext.prototype.type_list = function() { + return this.getTypedRuleContext(Type_listContext,0); +}; + +A_expr_is_notContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +A_expr_is_notContext.prototype.DOCUMENT_P = function() { + return this.getToken(PostgreSQLParser.DOCUMENT_P, 0); +}; + +A_expr_is_notContext.prototype.NORMALIZED = function() { + return this.getToken(PostgreSQLParser.NORMALIZED, 0); +}; + +A_expr_is_notContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +A_expr_is_notContext.prototype.unicode_normal_form = function() { + return this.getTypedRuleContext(Unicode_normal_formContext,0); +}; + +A_expr_is_notContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_is_not(this); + } +}; + +A_expr_is_notContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_is_not(this); + } +}; + +A_expr_is_notContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_is_not(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_is_notContext = A_expr_is_notContext; + +PostgreSQLParser.prototype.a_expr_is_not = function() { + + var localctx = new A_expr_is_notContext(this, this._ctx, this.state); + this.enterRule(localctx, 1168, PostgreSQLParser.RULE_a_expr_is_not); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8734; + this.a_expr_compare(); + this.state = 8758; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,533,this._ctx); + if(la_===1) { + this.state = 8735; + this.match(PostgreSQLParser.IS); + this.state = 8737; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.NOT) { + this.state = 8736; + this.match(PostgreSQLParser.NOT); + } + + this.state = 8756; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.NULL_P: + this.state = 8739; + this.match(PostgreSQLParser.NULL_P); + break; + case PostgreSQLParser.TRUE_P: + this.state = 8740; + this.match(PostgreSQLParser.TRUE_P); + break; + case PostgreSQLParser.FALSE_P: + this.state = 8741; + this.match(PostgreSQLParser.FALSE_P); + break; + case PostgreSQLParser.UNKNOWN: + this.state = 8742; + this.match(PostgreSQLParser.UNKNOWN); + break; + case PostgreSQLParser.DISTINCT: + this.state = 8743; + this.match(PostgreSQLParser.DISTINCT); + this.state = 8744; + this.match(PostgreSQLParser.FROM); + this.state = 8745; + this.a_expr(); + break; + case PostgreSQLParser.OF: + this.state = 8746; + this.match(PostgreSQLParser.OF); + this.state = 8747; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8748; + this.type_list(); + this.state = 8749; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.DOCUMENT_P: + this.state = 8751; + this.match(PostgreSQLParser.DOCUMENT_P); + break; + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + this.state = 8753; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(((((_la - 474)) & ~0x1f) == 0 && ((1 << (_la - 474)) & ((1 << (PostgreSQLParser.NFC - 474)) | (1 << (PostgreSQLParser.NFD - 474)) | (1 << (PostgreSQLParser.NFKC - 474)) | (1 << (PostgreSQLParser.NFKD - 474)))) !== 0)) { + this.state = 8752; + this.unicode_normal_form(); + } + + this.state = 8755; + this.match(PostgreSQLParser.NORMALIZED); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_compareContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_compare; + return this; +} + +A_expr_compareContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_compareContext.prototype.constructor = A_expr_compareContext; + +A_expr_compareContext.prototype.a_expr_like = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_expr_likeContext); + } else { + return this.getTypedRuleContext(A_expr_likeContext,i); + } +}; + +A_expr_compareContext.prototype.subquery_Op = function() { + return this.getTypedRuleContext(Subquery_OpContext,0); +}; + +A_expr_compareContext.prototype.sub_type = function() { + return this.getTypedRuleContext(Sub_typeContext,0); +}; + +A_expr_compareContext.prototype.LT = function() { + return this.getToken(PostgreSQLParser.LT, 0); +}; + +A_expr_compareContext.prototype.GT = function() { + return this.getToken(PostgreSQLParser.GT, 0); +}; + +A_expr_compareContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +A_expr_compareContext.prototype.LESS_EQUALS = function() { + return this.getToken(PostgreSQLParser.LESS_EQUALS, 0); +}; + +A_expr_compareContext.prototype.GREATER_EQUALS = function() { + return this.getToken(PostgreSQLParser.GREATER_EQUALS, 0); +}; + +A_expr_compareContext.prototype.NOT_EQUALS = function() { + return this.getToken(PostgreSQLParser.NOT_EQUALS, 0); +}; + +A_expr_compareContext.prototype.select_with_parens = function() { + return this.getTypedRuleContext(Select_with_parensContext,0); +}; + +A_expr_compareContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +A_expr_compareContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +A_expr_compareContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +A_expr_compareContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_compare(this); + } +}; + +A_expr_compareContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_compare(this); + } +}; + +A_expr_compareContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_compare(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_compareContext = A_expr_compareContext; + +PostgreSQLParser.prototype.a_expr_compare = function() { + + var localctx = new A_expr_compareContext(this, this._ctx, this.state); + this.enterRule(localctx, 1170, PostgreSQLParser.RULE_a_expr_compare); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8760; + this.a_expr_like(); + this.state = 8772; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,535,this._ctx); + if(la_===1) { + this.state = 8761; + _la = this._input.LA(1); + if(!((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << PostgreSQLParser.EQUAL) | (1 << PostgreSQLParser.LT) | (1 << PostgreSQLParser.GT) | (1 << PostgreSQLParser.LESS_EQUALS) | (1 << PostgreSQLParser.GREATER_EQUALS) | (1 << PostgreSQLParser.NOT_EQUALS))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8762; + this.a_expr_like(); + + } else if(la_===2) { + this.state = 8763; + this.subquery_Op(); + this.state = 8764; + this.sub_type(); + this.state = 8770; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,534,this._ctx); + switch(la_) { + case 1: + this.state = 8765; + this.select_with_parens(); + break; + + case 2: + this.state = 8766; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8767; + this.a_expr(); + this.state = 8768; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_likeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_like; + return this; +} + +A_expr_likeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_likeContext.prototype.constructor = A_expr_likeContext; + +A_expr_likeContext.prototype.a_expr_qual_op = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_expr_qual_opContext); + } else { + return this.getTypedRuleContext(A_expr_qual_opContext,i); + } +}; + +A_expr_likeContext.prototype.opt_escape = function() { + return this.getTypedRuleContext(Opt_escapeContext,0); +}; + +A_expr_likeContext.prototype.LIKE = function() { + return this.getToken(PostgreSQLParser.LIKE, 0); +}; + +A_expr_likeContext.prototype.ILIKE = function() { + return this.getToken(PostgreSQLParser.ILIKE, 0); +}; + +A_expr_likeContext.prototype.SIMILAR = function() { + return this.getToken(PostgreSQLParser.SIMILAR, 0); +}; + +A_expr_likeContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +A_expr_likeContext.prototype.BETWEEN = function() { + return this.getToken(PostgreSQLParser.BETWEEN, 0); +}; + +A_expr_likeContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +A_expr_likeContext.prototype.SYMMETRIC = function() { + return this.getToken(PostgreSQLParser.SYMMETRIC, 0); +}; + +A_expr_likeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_like(this); + } +}; + +A_expr_likeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_like(this); + } +}; + +A_expr_likeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_like(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_likeContext = A_expr_likeContext; + +PostgreSQLParser.prototype.a_expr_like = function() { + + var localctx = new A_expr_likeContext(this, this._ctx, this.state); + this.enterRule(localctx, 1172, PostgreSQLParser.RULE_a_expr_like); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8774; + this.a_expr_qual_op(); + this.state = 8791; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,539,this._ctx); + if(la_===1) { + this.state = 8776; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.NOT) { + this.state = 8775; + this.match(PostgreSQLParser.NOT); + } + + this.state = 8786; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.LIKE: + this.state = 8778; + this.match(PostgreSQLParser.LIKE); + break; + case PostgreSQLParser.ILIKE: + this.state = 8779; + this.match(PostgreSQLParser.ILIKE); + break; + case PostgreSQLParser.SIMILAR: + this.state = 8780; + this.match(PostgreSQLParser.SIMILAR); + this.state = 8781; + this.match(PostgreSQLParser.TO); + break; + case PostgreSQLParser.BETWEEN: + this.state = 8782; + this.match(PostgreSQLParser.BETWEEN); + this.state = 8784; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.SYMMETRIC) { + this.state = 8783; + this.match(PostgreSQLParser.SYMMETRIC); + } + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 8788; + this.a_expr_qual_op(); + this.state = 8789; + this.opt_escape(); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_qual_opContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_qual_op; + return this; +} + +A_expr_qual_opContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_qual_opContext.prototype.constructor = A_expr_qual_opContext; + +A_expr_qual_opContext.prototype.a_expr_unary_qualop = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_expr_unary_qualopContext); + } else { + return this.getTypedRuleContext(A_expr_unary_qualopContext,i); + } +}; + +A_expr_qual_opContext.prototype.qual_op = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Qual_opContext); + } else { + return this.getTypedRuleContext(Qual_opContext,i); + } +}; + +A_expr_qual_opContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_qual_op(this); + } +}; + +A_expr_qual_opContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_qual_op(this); + } +}; + +A_expr_qual_opContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_qual_op(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_qual_opContext = A_expr_qual_opContext; + +PostgreSQLParser.prototype.a_expr_qual_op = function() { + + var localctx = new A_expr_qual_opContext(this, this._ctx, this.state); + this.enterRule(localctx, 1174, PostgreSQLParser.RULE_a_expr_qual_op); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8793; + this.a_expr_unary_qualop(); + this.state = 8799; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,540,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 8794; + this.qual_op(); + this.state = 8795; + this.a_expr_unary_qualop(); + } + this.state = 8801; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,540,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_unary_qualopContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_unary_qualop; + return this; +} + +A_expr_unary_qualopContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_unary_qualopContext.prototype.constructor = A_expr_unary_qualopContext; + +A_expr_unary_qualopContext.prototype.a_expr_add = function() { + return this.getTypedRuleContext(A_expr_addContext,0); +}; + +A_expr_unary_qualopContext.prototype.qual_op = function() { + return this.getTypedRuleContext(Qual_opContext,0); +}; + +A_expr_unary_qualopContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_unary_qualop(this); + } +}; + +A_expr_unary_qualopContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_unary_qualop(this); + } +}; + +A_expr_unary_qualopContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_unary_qualop(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_unary_qualopContext = A_expr_unary_qualopContext; + +PostgreSQLParser.prototype.a_expr_unary_qualop = function() { + + var localctx = new A_expr_unary_qualopContext(this, this._ctx, this.state); + this.enterRule(localctx, 1176, PostgreSQLParser.RULE_a_expr_unary_qualop); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8803; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,541,this._ctx); + if(la_===1) { + this.state = 8802; + this.qual_op(); + + } + this.state = 8805; + this.a_expr_add(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_addContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_add; + return this; +} + +A_expr_addContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_addContext.prototype.constructor = A_expr_addContext; + +A_expr_addContext.prototype.a_expr_mul = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_expr_mulContext); + } else { + return this.getTypedRuleContext(A_expr_mulContext,i); + } +}; + +A_expr_addContext.prototype.MINUS = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.MINUS); + } else { + return this.getToken(PostgreSQLParser.MINUS, i); + } +}; + + +A_expr_addContext.prototype.PLUS = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.PLUS); + } else { + return this.getToken(PostgreSQLParser.PLUS, i); + } +}; + + +A_expr_addContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_add(this); + } +}; + +A_expr_addContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_add(this); + } +}; + +A_expr_addContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_add(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_addContext = A_expr_addContext; + +PostgreSQLParser.prototype.a_expr_add = function() { + + var localctx = new A_expr_addContext(this, this._ctx, this.state); + this.enterRule(localctx, 1178, PostgreSQLParser.RULE_a_expr_add); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8807; + this.a_expr_mul(); + this.state = 8812; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,542,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 8808; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.PLUS || _la===PostgreSQLParser.MINUS)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8809; + this.a_expr_mul(); + } + this.state = 8814; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,542,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_mulContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_mul; + return this; +} + +A_expr_mulContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_mulContext.prototype.constructor = A_expr_mulContext; + +A_expr_mulContext.prototype.a_expr_caret = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_expr_caretContext); + } else { + return this.getTypedRuleContext(A_expr_caretContext,i); + } +}; + +A_expr_mulContext.prototype.STAR = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.STAR); + } else { + return this.getToken(PostgreSQLParser.STAR, i); + } +}; + + +A_expr_mulContext.prototype.SLASH = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.SLASH); + } else { + return this.getToken(PostgreSQLParser.SLASH, i); + } +}; + + +A_expr_mulContext.prototype.PERCENT = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.PERCENT); + } else { + return this.getToken(PostgreSQLParser.PERCENT, i); + } +}; + + +A_expr_mulContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_mul(this); + } +}; + +A_expr_mulContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_mul(this); + } +}; + +A_expr_mulContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_mul(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_mulContext = A_expr_mulContext; + +PostgreSQLParser.prototype.a_expr_mul = function() { + + var localctx = new A_expr_mulContext(this, this._ctx, this.state); + this.enterRule(localctx, 1180, PostgreSQLParser.RULE_a_expr_mul); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8815; + this.a_expr_caret(); + this.state = 8820; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,543,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 8816; + _la = this._input.LA(1); + if(!((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << PostgreSQLParser.STAR) | (1 << PostgreSQLParser.SLASH) | (1 << PostgreSQLParser.PERCENT))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8817; + this.a_expr_caret(); + } + this.state = 8822; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,543,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_caretContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_caret; + return this; +} + +A_expr_caretContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_caretContext.prototype.constructor = A_expr_caretContext; + +A_expr_caretContext.prototype.a_expr_unary_sign = function() { + return this.getTypedRuleContext(A_expr_unary_signContext,0); +}; + +A_expr_caretContext.prototype.CARET = function() { + return this.getToken(PostgreSQLParser.CARET, 0); +}; + +A_expr_caretContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +A_expr_caretContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_caret(this); + } +}; + +A_expr_caretContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_caret(this); + } +}; + +A_expr_caretContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_caret(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_caretContext = A_expr_caretContext; + +PostgreSQLParser.prototype.a_expr_caret = function() { + + var localctx = new A_expr_caretContext(this, this._ctx, this.state); + this.enterRule(localctx, 1182, PostgreSQLParser.RULE_a_expr_caret); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8823; + this.a_expr_unary_sign(); + this.state = 8826; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,544,this._ctx); + if(la_===1) { + this.state = 8824; + this.match(PostgreSQLParser.CARET); + this.state = 8825; + this.a_expr(); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_unary_signContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_unary_sign; + return this; +} + +A_expr_unary_signContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_unary_signContext.prototype.constructor = A_expr_unary_signContext; + +A_expr_unary_signContext.prototype.a_expr_at_time_zone = function() { + return this.getTypedRuleContext(A_expr_at_time_zoneContext,0); +}; + +A_expr_unary_signContext.prototype.MINUS = function() { + return this.getToken(PostgreSQLParser.MINUS, 0); +}; + +A_expr_unary_signContext.prototype.PLUS = function() { + return this.getToken(PostgreSQLParser.PLUS, 0); +}; + +A_expr_unary_signContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_unary_sign(this); + } +}; + +A_expr_unary_signContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_unary_sign(this); + } +}; + +A_expr_unary_signContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_unary_sign(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_unary_signContext = A_expr_unary_signContext; + +PostgreSQLParser.prototype.a_expr_unary_sign = function() { + + var localctx = new A_expr_unary_signContext(this, this._ctx, this.state); + this.enterRule(localctx, 1184, PostgreSQLParser.RULE_a_expr_unary_sign); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8829; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.PLUS || _la===PostgreSQLParser.MINUS) { + this.state = 8828; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.PLUS || _la===PostgreSQLParser.MINUS)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } + + this.state = 8831; + this.a_expr_at_time_zone(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_at_time_zoneContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_at_time_zone; + return this; +} + +A_expr_at_time_zoneContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_at_time_zoneContext.prototype.constructor = A_expr_at_time_zoneContext; + +A_expr_at_time_zoneContext.prototype.a_expr_collate = function() { + return this.getTypedRuleContext(A_expr_collateContext,0); +}; + +A_expr_at_time_zoneContext.prototype.AT = function() { + return this.getToken(PostgreSQLParser.AT, 0); +}; + +A_expr_at_time_zoneContext.prototype.TIME = function() { + return this.getToken(PostgreSQLParser.TIME, 0); +}; + +A_expr_at_time_zoneContext.prototype.ZONE = function() { + return this.getToken(PostgreSQLParser.ZONE, 0); +}; + +A_expr_at_time_zoneContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +A_expr_at_time_zoneContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_at_time_zone(this); + } +}; + +A_expr_at_time_zoneContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_at_time_zone(this); + } +}; + +A_expr_at_time_zoneContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_at_time_zone(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_at_time_zoneContext = A_expr_at_time_zoneContext; + +PostgreSQLParser.prototype.a_expr_at_time_zone = function() { + + var localctx = new A_expr_at_time_zoneContext(this, this._ctx, this.state); + this.enterRule(localctx, 1186, PostgreSQLParser.RULE_a_expr_at_time_zone); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8833; + this.a_expr_collate(); + this.state = 8838; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,546,this._ctx); + if(la_===1) { + this.state = 8834; + this.match(PostgreSQLParser.AT); + this.state = 8835; + this.match(PostgreSQLParser.TIME); + this.state = 8836; + this.match(PostgreSQLParser.ZONE); + this.state = 8837; + this.a_expr(); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_collateContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_collate; + return this; +} + +A_expr_collateContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_collateContext.prototype.constructor = A_expr_collateContext; + +A_expr_collateContext.prototype.a_expr_typecast = function() { + return this.getTypedRuleContext(A_expr_typecastContext,0); +}; + +A_expr_collateContext.prototype.COLLATE = function() { + return this.getToken(PostgreSQLParser.COLLATE, 0); +}; + +A_expr_collateContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +A_expr_collateContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_collate(this); + } +}; + +A_expr_collateContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_collate(this); + } +}; + +A_expr_collateContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_collate(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_collateContext = A_expr_collateContext; + +PostgreSQLParser.prototype.a_expr_collate = function() { + + var localctx = new A_expr_collateContext(this, this._ctx, this.state); + this.enterRule(localctx, 1188, PostgreSQLParser.RULE_a_expr_collate); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8840; + this.a_expr_typecast(); + this.state = 8843; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,547,this._ctx); + if(la_===1) { + this.state = 8841; + this.match(PostgreSQLParser.COLLATE); + this.state = 8842; + this.any_name(); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function A_expr_typecastContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_a_expr_typecast; + return this; +} + +A_expr_typecastContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +A_expr_typecastContext.prototype.constructor = A_expr_typecastContext; + +A_expr_typecastContext.prototype.c_expr = function() { + return this.getTypedRuleContext(C_exprContext,0); +}; + +A_expr_typecastContext.prototype.TYPECAST = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.TYPECAST); + } else { + return this.getToken(PostgreSQLParser.TYPECAST, i); + } +}; + + +A_expr_typecastContext.prototype.typename = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TypenameContext); + } else { + return this.getTypedRuleContext(TypenameContext,i); + } +}; + +A_expr_typecastContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterA_expr_typecast(this); + } +}; + +A_expr_typecastContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitA_expr_typecast(this); + } +}; + +A_expr_typecastContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitA_expr_typecast(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.A_expr_typecastContext = A_expr_typecastContext; + +PostgreSQLParser.prototype.a_expr_typecast = function() { + + var localctx = new A_expr_typecastContext(this, this._ctx, this.state); + this.enterRule(localctx, 1190, PostgreSQLParser.RULE_a_expr_typecast); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8845; + this.c_expr(); + this.state = 8850; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.TYPECAST) { + this.state = 8846; + this.match(PostgreSQLParser.TYPECAST); + this.state = 8847; + this.typename(); + this.state = 8852; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function B_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_b_expr; + return this; +} + +B_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +B_exprContext.prototype.constructor = B_exprContext; + +B_exprContext.prototype.c_expr = function() { + return this.getTypedRuleContext(C_exprContext,0); +}; + +B_exprContext.prototype.b_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(B_exprContext); + } else { + return this.getTypedRuleContext(B_exprContext,i); + } +}; + +B_exprContext.prototype.PLUS = function() { + return this.getToken(PostgreSQLParser.PLUS, 0); +}; + +B_exprContext.prototype.MINUS = function() { + return this.getToken(PostgreSQLParser.MINUS, 0); +}; + +B_exprContext.prototype.qual_op = function() { + return this.getTypedRuleContext(Qual_opContext,0); +}; + +B_exprContext.prototype.CARET = function() { + return this.getToken(PostgreSQLParser.CARET, 0); +}; + +B_exprContext.prototype.STAR = function() { + return this.getToken(PostgreSQLParser.STAR, 0); +}; + +B_exprContext.prototype.SLASH = function() { + return this.getToken(PostgreSQLParser.SLASH, 0); +}; + +B_exprContext.prototype.PERCENT = function() { + return this.getToken(PostgreSQLParser.PERCENT, 0); +}; + +B_exprContext.prototype.LT = function() { + return this.getToken(PostgreSQLParser.LT, 0); +}; + +B_exprContext.prototype.GT = function() { + return this.getToken(PostgreSQLParser.GT, 0); +}; + +B_exprContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +B_exprContext.prototype.LESS_EQUALS = function() { + return this.getToken(PostgreSQLParser.LESS_EQUALS, 0); +}; + +B_exprContext.prototype.GREATER_EQUALS = function() { + return this.getToken(PostgreSQLParser.GREATER_EQUALS, 0); +}; + +B_exprContext.prototype.NOT_EQUALS = function() { + return this.getToken(PostgreSQLParser.NOT_EQUALS, 0); +}; + +B_exprContext.prototype.TYPECAST = function() { + return this.getToken(PostgreSQLParser.TYPECAST, 0); +}; + +B_exprContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +B_exprContext.prototype.IS = function() { + return this.getToken(PostgreSQLParser.IS, 0); +}; + +B_exprContext.prototype.DISTINCT = function() { + return this.getToken(PostgreSQLParser.DISTINCT, 0); +}; + +B_exprContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +B_exprContext.prototype.OF = function() { + return this.getToken(PostgreSQLParser.OF, 0); +}; + +B_exprContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +B_exprContext.prototype.type_list = function() { + return this.getTypedRuleContext(Type_listContext,0); +}; + +B_exprContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +B_exprContext.prototype.DOCUMENT_P = function() { + return this.getToken(PostgreSQLParser.DOCUMENT_P, 0); +}; + +B_exprContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +B_exprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterB_expr(this); + } +}; + +B_exprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitB_expr(this); + } +}; + +B_exprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitB_expr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + +PostgreSQLParser.prototype.b_expr = function(_p) { + if(_p===undefined) { + _p = 0; + } + var _parentctx = this._ctx; + var _parentState = this.state; + var localctx = new B_exprContext(this, this._ctx, _parentState); + var _prevctx = localctx; + var _startState = 1192; + this.enterRecursionRule(localctx, 1192, PostgreSQLParser.RULE_b_expr, _p); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8860; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,549,this._ctx); + switch(la_) { + case 1: + this.state = 8854; + this.c_expr(); + break; + + case 2: + this.state = 8855; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.PLUS || _la===PostgreSQLParser.MINUS)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8856; + this.b_expr(9); + break; + + case 3: + this.state = 8857; + this.qual_op(); + this.state = 8858; + this.b_expr(3); + break; + + } + this._ctx.stop = this._input.LT(-1); + this.state = 8901; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,553,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + if(this._parseListeners!==null) { + this.triggerExitRuleEvent(); + } + _prevctx = localctx; + this.state = 8899; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,552,this._ctx); + switch(la_) { + case 1: + localctx = new B_exprContext(this, _parentctx, _parentState); + this.pushNewRecursionContext(localctx, _startState, PostgreSQLParser.RULE_b_expr); + this.state = 8862; + if (!( this.precpred(this._ctx, 8))) { + throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 8)"); + } + this.state = 8863; + this.match(PostgreSQLParser.CARET); + this.state = 8864; + this.b_expr(9); + break; + + case 2: + localctx = new B_exprContext(this, _parentctx, _parentState); + this.pushNewRecursionContext(localctx, _startState, PostgreSQLParser.RULE_b_expr); + this.state = 8865; + if (!( this.precpred(this._ctx, 7))) { + throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 7)"); + } + this.state = 8866; + _la = this._input.LA(1); + if(!((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << PostgreSQLParser.STAR) | (1 << PostgreSQLParser.SLASH) | (1 << PostgreSQLParser.PERCENT))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8867; + this.b_expr(8); + break; + + case 3: + localctx = new B_exprContext(this, _parentctx, _parentState); + this.pushNewRecursionContext(localctx, _startState, PostgreSQLParser.RULE_b_expr); + this.state = 8868; + if (!( this.precpred(this._ctx, 6))) { + throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 6)"); + } + this.state = 8869; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.PLUS || _la===PostgreSQLParser.MINUS)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8870; + this.b_expr(7); + break; + + case 4: + localctx = new B_exprContext(this, _parentctx, _parentState); + this.pushNewRecursionContext(localctx, _startState, PostgreSQLParser.RULE_b_expr); + this.state = 8871; + if (!( this.precpred(this._ctx, 5))) { + throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 5)"); + } + this.state = 8872; + this.qual_op(); + this.state = 8873; + this.b_expr(6); + break; + + case 5: + localctx = new B_exprContext(this, _parentctx, _parentState); + this.pushNewRecursionContext(localctx, _startState, PostgreSQLParser.RULE_b_expr); + this.state = 8875; + if (!( this.precpred(this._ctx, 4))) { + throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 4)"); + } + this.state = 8876; + _la = this._input.LA(1); + if(!((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << PostgreSQLParser.EQUAL) | (1 << PostgreSQLParser.LT) | (1 << PostgreSQLParser.GT) | (1 << PostgreSQLParser.LESS_EQUALS) | (1 << PostgreSQLParser.GREATER_EQUALS) | (1 << PostgreSQLParser.NOT_EQUALS))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8877; + this.b_expr(5); + break; + + case 6: + localctx = new B_exprContext(this, _parentctx, _parentState); + this.pushNewRecursionContext(localctx, _startState, PostgreSQLParser.RULE_b_expr); + this.state = 8878; + if (!( this.precpred(this._ctx, 10))) { + throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 10)"); + } + this.state = 8879; + this.match(PostgreSQLParser.TYPECAST); + this.state = 8880; + this.typename(); + break; + + case 7: + localctx = new B_exprContext(this, _parentctx, _parentState); + this.pushNewRecursionContext(localctx, _startState, PostgreSQLParser.RULE_b_expr); + this.state = 8881; + if (!( this.precpred(this._ctx, 2))) { + throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 2)"); + } + this.state = 8882; + this.qual_op(); + break; + + case 8: + localctx = new B_exprContext(this, _parentctx, _parentState); + this.pushNewRecursionContext(localctx, _startState, PostgreSQLParser.RULE_b_expr); + this.state = 8883; + if (!( this.precpred(this._ctx, 1))) { + throw new antlr4.error.FailedPredicateException(this, "this.precpred(this._ctx, 1)"); + } + this.state = 8884; + this.match(PostgreSQLParser.IS); + this.state = 8886; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.NOT) { + this.state = 8885; + this.match(PostgreSQLParser.NOT); + } + + this.state = 8897; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.DISTINCT: + this.state = 8888; + this.match(PostgreSQLParser.DISTINCT); + this.state = 8889; + this.match(PostgreSQLParser.FROM); + this.state = 8890; + this.b_expr(0); + break; + case PostgreSQLParser.OF: + this.state = 8891; + this.match(PostgreSQLParser.OF); + this.state = 8892; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8893; + this.type_list(); + this.state = 8894; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.DOCUMENT_P: + this.state = 8896; + this.match(PostgreSQLParser.DOCUMENT_P); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + } + } + this.state = 8903; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,553,this._ctx); + } + + } catch( error) { + if(error instanceof antlr4.error.RecognitionException) { + localctx.exception = error; + this._errHandler.reportError(this, error); + this._errHandler.recover(this, error); + } else { + throw error; + } + } finally { + this.unrollRecursionContexts(_parentctx) + } + return localctx; +}; + + +function C_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_c_expr; + return this; +} + +C_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +C_exprContext.prototype.constructor = C_exprContext; + + + +C_exprContext.prototype.copyFrom = function(ctx) { + antlr4.ParserRuleContext.prototype.copyFrom.call(this, ctx); +}; + + +function C_expr_existsContext(parser, ctx) { + C_exprContext.call(this, parser); + C_exprContext.prototype.copyFrom.call(this, ctx); + return this; +} + +C_expr_existsContext.prototype = Object.create(C_exprContext.prototype); +C_expr_existsContext.prototype.constructor = C_expr_existsContext; + +PostgreSQLParser.C_expr_existsContext = C_expr_existsContext; + +C_expr_existsContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +C_expr_existsContext.prototype.select_with_parens = function() { + return this.getTypedRuleContext(Select_with_parensContext,0); +}; +C_expr_existsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterC_expr_exists(this); + } +}; + +C_expr_existsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitC_expr_exists(this); + } +}; + +C_expr_existsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitC_expr_exists(this); + } else { + return visitor.visitChildren(this); + } +}; + + +function C_expr_caseContext(parser, ctx) { + C_exprContext.call(this, parser); + C_exprContext.prototype.copyFrom.call(this, ctx); + return this; +} + +C_expr_caseContext.prototype = Object.create(C_exprContext.prototype); +C_expr_caseContext.prototype.constructor = C_expr_caseContext; + +PostgreSQLParser.C_expr_caseContext = C_expr_caseContext; + +C_expr_caseContext.prototype.case_expr = function() { + return this.getTypedRuleContext(Case_exprContext,0); +}; +C_expr_caseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterC_expr_case(this); + } +}; + +C_expr_caseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitC_expr_case(this); + } +}; + +C_expr_caseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitC_expr_case(this); + } else { + return visitor.visitChildren(this); + } +}; + + +function C_expr_exprContext(parser, ctx) { + C_exprContext.call(this, parser); + this.a_expr_in_parens = null; // A_exprContext; + C_exprContext.prototype.copyFrom.call(this, ctx); + return this; +} + +C_expr_exprContext.prototype = Object.create(C_exprContext.prototype); +C_expr_exprContext.prototype.constructor = C_expr_exprContext; + +PostgreSQLParser.C_expr_exprContext = C_expr_exprContext; + +C_expr_exprContext.prototype.ARRAY = function() { + return this.getToken(PostgreSQLParser.ARRAY, 0); +}; + +C_expr_exprContext.prototype.select_with_parens = function() { + return this.getTypedRuleContext(Select_with_parensContext,0); +}; + +C_expr_exprContext.prototype.array_expr = function() { + return this.getTypedRuleContext(Array_exprContext,0); +}; + +C_expr_exprContext.prototype.PARAM = function() { + return this.getToken(PostgreSQLParser.PARAM, 0); +}; + +C_expr_exprContext.prototype.opt_indirection = function() { + return this.getTypedRuleContext(Opt_indirectionContext,0); +}; + +C_expr_exprContext.prototype.GROUPING = function() { + return this.getToken(PostgreSQLParser.GROUPING, 0); +}; + +C_expr_exprContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +C_expr_exprContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +C_expr_exprContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +C_expr_exprContext.prototype.UNIQUE = function() { + return this.getToken(PostgreSQLParser.UNIQUE, 0); +}; + +C_expr_exprContext.prototype.columnref = function() { + return this.getTypedRuleContext(ColumnrefContext,0); +}; + +C_expr_exprContext.prototype.aexprconst = function() { + return this.getTypedRuleContext(AexprconstContext,0); +}; + +C_expr_exprContext.prototype.plsqlvariablename = function() { + return this.getTypedRuleContext(PlsqlvariablenameContext,0); +}; + +C_expr_exprContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +C_expr_exprContext.prototype.func_expr = function() { + return this.getTypedRuleContext(Func_exprContext,0); +}; + +C_expr_exprContext.prototype.indirection = function() { + return this.getTypedRuleContext(IndirectionContext,0); +}; + +C_expr_exprContext.prototype.explicit_row = function() { + return this.getTypedRuleContext(Explicit_rowContext,0); +}; + +C_expr_exprContext.prototype.implicit_row = function() { + return this.getTypedRuleContext(Implicit_rowContext,0); +}; + +C_expr_exprContext.prototype.row = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(RowContext); + } else { + return this.getTypedRuleContext(RowContext,i); + } +}; + +C_expr_exprContext.prototype.OVERLAPS = function() { + return this.getToken(PostgreSQLParser.OVERLAPS, 0); +}; +C_expr_exprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterC_expr_expr(this); + } +}; + +C_expr_exprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitC_expr_expr(this); + } +}; + +C_expr_exprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitC_expr_expr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + +PostgreSQLParser.C_exprContext = C_exprContext; + +PostgreSQLParser.prototype.c_expr = function() { + + var localctx = new C_exprContext(this, this._ctx, this.state); + this.enterRule(localctx, 1194, PostgreSQLParser.RULE_c_expr); + try { + this.state = 8940; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,556,this._ctx); + switch(la_) { + case 1: + localctx = new C_expr_existsContext(this, localctx); + this.enterOuterAlt(localctx, 1); + this.state = 8904; + this.match(PostgreSQLParser.EXISTS); + this.state = 8905; + this.select_with_parens(); + break; + + case 2: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 2); + this.state = 8906; + this.match(PostgreSQLParser.ARRAY); + this.state = 8909; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + this.state = 8907; + this.select_with_parens(); + break; + case PostgreSQLParser.OPEN_BRACKET: + this.state = 8908; + this.array_expr(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 3: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 3); + this.state = 8911; + this.match(PostgreSQLParser.PARAM); + this.state = 8912; + this.opt_indirection(); + break; + + case 4: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 4); + this.state = 8913; + this.match(PostgreSQLParser.GROUPING); + this.state = 8914; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8915; + this.expr_list(); + this.state = 8916; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 5: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 5); + this.state = 8918; + this.match(PostgreSQLParser.UNIQUE); + this.state = 8919; + this.select_with_parens(); + break; + + case 6: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 6); + this.state = 8920; + this.columnref(); + break; + + case 7: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 7); + this.state = 8921; + this.aexprconst(); + break; + + case 8: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 8); + this.state = 8922; + this.plsqlvariablename(); + break; + + case 9: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 9); + this.state = 8923; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8924; + localctx.a_expr_in_parens = this.a_expr(); + this.state = 8925; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 8926; + this.opt_indirection(); + break; + + case 10: + localctx = new C_expr_caseContext(this, localctx); + this.enterOuterAlt(localctx, 10); + this.state = 8928; + this.case_expr(); + break; + + case 11: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 11); + this.state = 8929; + this.func_expr(); + break; + + case 12: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 12); + this.state = 8930; + this.select_with_parens(); + this.state = 8932; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,555,this._ctx); + if(la_===1) { + this.state = 8931; + this.indirection(); + + } + break; + + case 13: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 13); + this.state = 8934; + this.explicit_row(); + break; + + case 14: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 14); + this.state = 8935; + this.implicit_row(); + break; + + case 15: + localctx = new C_expr_exprContext(this, localctx); + this.enterOuterAlt(localctx, 15); + this.state = 8936; + this.row(); + this.state = 8937; + this.match(PostgreSQLParser.OVERLAPS); + this.state = 8938; + this.row(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function PlsqlvariablenameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_plsqlvariablename; + return this; +} + +PlsqlvariablenameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +PlsqlvariablenameContext.prototype.constructor = PlsqlvariablenameContext; + +PlsqlvariablenameContext.prototype.PLSQLVARIABLENAME = function() { + return this.getToken(PostgreSQLParser.PLSQLVARIABLENAME, 0); +}; + +PlsqlvariablenameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPlsqlvariablename(this); + } +}; + +PlsqlvariablenameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPlsqlvariablename(this); + } +}; + +PlsqlvariablenameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPlsqlvariablename(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.PlsqlvariablenameContext = PlsqlvariablenameContext; + +PostgreSQLParser.prototype.plsqlvariablename = function() { + + var localctx = new PlsqlvariablenameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1196, PostgreSQLParser.RULE_plsqlvariablename); + try { + this.enterOuterAlt(localctx, 1); + this.state = 8942; + this.match(PostgreSQLParser.PLSQLVARIABLENAME); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_applicationContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_application; + return this; +} + +Func_applicationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_applicationContext.prototype.constructor = Func_applicationContext; + +Func_applicationContext.prototype.func_name = function() { + return this.getTypedRuleContext(Func_nameContext,0); +}; + +Func_applicationContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Func_applicationContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Func_applicationContext.prototype.func_arg_list = function() { + return this.getTypedRuleContext(Func_arg_listContext,0); +}; + +Func_applicationContext.prototype.opt_sort_clause = function() { + return this.getTypedRuleContext(Opt_sort_clauseContext,0); +}; + +Func_applicationContext.prototype.VARIADIC = function() { + return this.getToken(PostgreSQLParser.VARIADIC, 0); +}; + +Func_applicationContext.prototype.func_arg_expr = function() { + return this.getTypedRuleContext(Func_arg_exprContext,0); +}; + +Func_applicationContext.prototype.STAR = function() { + return this.getToken(PostgreSQLParser.STAR, 0); +}; + +Func_applicationContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Func_applicationContext.prototype.DISTINCT = function() { + return this.getToken(PostgreSQLParser.DISTINCT, 0); +}; + +Func_applicationContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +Func_applicationContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_application(this); + } +}; + +Func_applicationContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_application(this); + } +}; + +Func_applicationContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_application(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_applicationContext = Func_applicationContext; + +PostgreSQLParser.prototype.func_application = function() { + + var localctx = new Func_applicationContext(this, this._ctx, this.state); + this.enterRule(localctx, 1198, PostgreSQLParser.RULE_func_application); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 8944; + this.func_name(); + this.state = 8945; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8964; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.Operator: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.state = 8946; + this.func_arg_list(); + this.state = 8950; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.COMMA) { + this.state = 8947; + this.match(PostgreSQLParser.COMMA); + this.state = 8948; + this.match(PostgreSQLParser.VARIADIC); + this.state = 8949; + this.func_arg_expr(); + } + + this.state = 8952; + this.opt_sort_clause(); + break; + case PostgreSQLParser.VARIADIC: + this.state = 8954; + this.match(PostgreSQLParser.VARIADIC); + this.state = 8955; + this.func_arg_expr(); + this.state = 8956; + this.opt_sort_clause(); + break; + case PostgreSQLParser.ALL: + case PostgreSQLParser.DISTINCT: + this.state = 8958; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.ALL || _la===PostgreSQLParser.DISTINCT)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 8959; + this.func_arg_list(); + this.state = 8960; + this.opt_sort_clause(); + break; + case PostgreSQLParser.STAR: + this.state = 8962; + this.match(PostgreSQLParser.STAR); + break; + case PostgreSQLParser.CLOSE_PAREN: + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 8966; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_expr; + return this; +} + +Func_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_exprContext.prototype.constructor = Func_exprContext; + +Func_exprContext.prototype.func_application = function() { + return this.getTypedRuleContext(Func_applicationContext,0); +}; + +Func_exprContext.prototype.within_group_clause = function() { + return this.getTypedRuleContext(Within_group_clauseContext,0); +}; + +Func_exprContext.prototype.filter_clause = function() { + return this.getTypedRuleContext(Filter_clauseContext,0); +}; + +Func_exprContext.prototype.over_clause = function() { + return this.getTypedRuleContext(Over_clauseContext,0); +}; + +Func_exprContext.prototype.func_expr_common_subexpr = function() { + return this.getTypedRuleContext(Func_expr_common_subexprContext,0); +}; + +Func_exprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_expr(this); + } +}; + +Func_exprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_expr(this); + } +}; + +Func_exprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_expr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_exprContext = Func_exprContext; + +PostgreSQLParser.prototype.func_expr = function() { + + var localctx = new Func_exprContext(this, this._ctx, this.state); + this.enterRule(localctx, 1200, PostgreSQLParser.RULE_func_expr); + try { + this.state = 8974; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,559,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8968; + this.func_application(); + this.state = 8969; + this.within_group_clause(); + this.state = 8970; + this.filter_clause(); + this.state = 8971; + this.over_clause(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8973; + this.func_expr_common_subexpr(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_expr_windowlessContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_expr_windowless; + return this; +} + +Func_expr_windowlessContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_expr_windowlessContext.prototype.constructor = Func_expr_windowlessContext; + +Func_expr_windowlessContext.prototype.func_application = function() { + return this.getTypedRuleContext(Func_applicationContext,0); +}; + +Func_expr_windowlessContext.prototype.func_expr_common_subexpr = function() { + return this.getTypedRuleContext(Func_expr_common_subexprContext,0); +}; + +Func_expr_windowlessContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_expr_windowless(this); + } +}; + +Func_expr_windowlessContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_expr_windowless(this); + } +}; + +Func_expr_windowlessContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_expr_windowless(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_expr_windowlessContext = Func_expr_windowlessContext; + +PostgreSQLParser.prototype.func_expr_windowless = function() { + + var localctx = new Func_expr_windowlessContext(this, this._ctx, this.state); + this.enterRule(localctx, 1202, PostgreSQLParser.RULE_func_expr_windowless); + try { + this.state = 8978; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,560,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 8976; + this.func_application(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 8977; + this.func_expr_common_subexpr(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_expr_common_subexprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_expr_common_subexpr; + return this; +} + +Func_expr_common_subexprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_expr_common_subexprContext.prototype.constructor = Func_expr_common_subexprContext; + +Func_expr_common_subexprContext.prototype.COLLATION = function() { + return this.getToken(PostgreSQLParser.COLLATION, 0); +}; + +Func_expr_common_subexprContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Func_expr_common_subexprContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Func_expr_common_subexprContext.prototype.a_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_exprContext); + } else { + return this.getTypedRuleContext(A_exprContext,i); + } +}; + +Func_expr_common_subexprContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Func_expr_common_subexprContext.prototype.CURRENT_DATE = function() { + return this.getToken(PostgreSQLParser.CURRENT_DATE, 0); +}; + +Func_expr_common_subexprContext.prototype.CURRENT_TIME = function() { + return this.getToken(PostgreSQLParser.CURRENT_TIME, 0); +}; + +Func_expr_common_subexprContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +Func_expr_common_subexprContext.prototype.CURRENT_TIMESTAMP = function() { + return this.getToken(PostgreSQLParser.CURRENT_TIMESTAMP, 0); +}; + +Func_expr_common_subexprContext.prototype.LOCALTIME = function() { + return this.getToken(PostgreSQLParser.LOCALTIME, 0); +}; + +Func_expr_common_subexprContext.prototype.LOCALTIMESTAMP = function() { + return this.getToken(PostgreSQLParser.LOCALTIMESTAMP, 0); +}; + +Func_expr_common_subexprContext.prototype.CURRENT_ROLE = function() { + return this.getToken(PostgreSQLParser.CURRENT_ROLE, 0); +}; + +Func_expr_common_subexprContext.prototype.CURRENT_USER = function() { + return this.getToken(PostgreSQLParser.CURRENT_USER, 0); +}; + +Func_expr_common_subexprContext.prototype.SESSION_USER = function() { + return this.getToken(PostgreSQLParser.SESSION_USER, 0); +}; + +Func_expr_common_subexprContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +Func_expr_common_subexprContext.prototype.CURRENT_CATALOG = function() { + return this.getToken(PostgreSQLParser.CURRENT_CATALOG, 0); +}; + +Func_expr_common_subexprContext.prototype.CURRENT_SCHEMA = function() { + return this.getToken(PostgreSQLParser.CURRENT_SCHEMA, 0); +}; + +Func_expr_common_subexprContext.prototype.CAST = function() { + return this.getToken(PostgreSQLParser.CAST, 0); +}; + +Func_expr_common_subexprContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Func_expr_common_subexprContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +Func_expr_common_subexprContext.prototype.EXTRACT = function() { + return this.getToken(PostgreSQLParser.EXTRACT, 0); +}; + +Func_expr_common_subexprContext.prototype.extract_list = function() { + return this.getTypedRuleContext(Extract_listContext,0); +}; + +Func_expr_common_subexprContext.prototype.NORMALIZE = function() { + return this.getToken(PostgreSQLParser.NORMALIZE, 0); +}; + +Func_expr_common_subexprContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +Func_expr_common_subexprContext.prototype.unicode_normal_form = function() { + return this.getTypedRuleContext(Unicode_normal_formContext,0); +}; + +Func_expr_common_subexprContext.prototype.OVERLAY = function() { + return this.getToken(PostgreSQLParser.OVERLAY, 0); +}; + +Func_expr_common_subexprContext.prototype.overlay_list = function() { + return this.getTypedRuleContext(Overlay_listContext,0); +}; + +Func_expr_common_subexprContext.prototype.POSITION = function() { + return this.getToken(PostgreSQLParser.POSITION, 0); +}; + +Func_expr_common_subexprContext.prototype.position_list = function() { + return this.getTypedRuleContext(Position_listContext,0); +}; + +Func_expr_common_subexprContext.prototype.SUBSTRING = function() { + return this.getToken(PostgreSQLParser.SUBSTRING, 0); +}; + +Func_expr_common_subexprContext.prototype.substr_list = function() { + return this.getTypedRuleContext(Substr_listContext,0); +}; + +Func_expr_common_subexprContext.prototype.TREAT = function() { + return this.getToken(PostgreSQLParser.TREAT, 0); +}; + +Func_expr_common_subexprContext.prototype.TRIM = function() { + return this.getToken(PostgreSQLParser.TRIM, 0); +}; + +Func_expr_common_subexprContext.prototype.trim_list = function() { + return this.getTypedRuleContext(Trim_listContext,0); +}; + +Func_expr_common_subexprContext.prototype.BOTH = function() { + return this.getToken(PostgreSQLParser.BOTH, 0); +}; + +Func_expr_common_subexprContext.prototype.LEADING = function() { + return this.getToken(PostgreSQLParser.LEADING, 0); +}; + +Func_expr_common_subexprContext.prototype.TRAILING = function() { + return this.getToken(PostgreSQLParser.TRAILING, 0); +}; + +Func_expr_common_subexprContext.prototype.NULLIF = function() { + return this.getToken(PostgreSQLParser.NULLIF, 0); +}; + +Func_expr_common_subexprContext.prototype.COALESCE = function() { + return this.getToken(PostgreSQLParser.COALESCE, 0); +}; + +Func_expr_common_subexprContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Func_expr_common_subexprContext.prototype.GREATEST = function() { + return this.getToken(PostgreSQLParser.GREATEST, 0); +}; + +Func_expr_common_subexprContext.prototype.LEAST = function() { + return this.getToken(PostgreSQLParser.LEAST, 0); +}; + +Func_expr_common_subexprContext.prototype.XMLCONCAT = function() { + return this.getToken(PostgreSQLParser.XMLCONCAT, 0); +}; + +Func_expr_common_subexprContext.prototype.XMLELEMENT = function() { + return this.getToken(PostgreSQLParser.XMLELEMENT, 0); +}; + +Func_expr_common_subexprContext.prototype.NAME_P = function() { + return this.getToken(PostgreSQLParser.NAME_P, 0); +}; + +Func_expr_common_subexprContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +Func_expr_common_subexprContext.prototype.xml_attributes = function() { + return this.getTypedRuleContext(Xml_attributesContext,0); +}; + +Func_expr_common_subexprContext.prototype.XMLEXISTS = function() { + return this.getToken(PostgreSQLParser.XMLEXISTS, 0); +}; + +Func_expr_common_subexprContext.prototype.c_expr = function() { + return this.getTypedRuleContext(C_exprContext,0); +}; + +Func_expr_common_subexprContext.prototype.xmlexists_argument = function() { + return this.getTypedRuleContext(Xmlexists_argumentContext,0); +}; + +Func_expr_common_subexprContext.prototype.XMLFOREST = function() { + return this.getToken(PostgreSQLParser.XMLFOREST, 0); +}; + +Func_expr_common_subexprContext.prototype.xml_attribute_list = function() { + return this.getTypedRuleContext(Xml_attribute_listContext,0); +}; + +Func_expr_common_subexprContext.prototype.XMLPARSE = function() { + return this.getToken(PostgreSQLParser.XMLPARSE, 0); +}; + +Func_expr_common_subexprContext.prototype.document_or_content = function() { + return this.getTypedRuleContext(Document_or_contentContext,0); +}; + +Func_expr_common_subexprContext.prototype.xml_whitespace_option = function() { + return this.getTypedRuleContext(Xml_whitespace_optionContext,0); +}; + +Func_expr_common_subexprContext.prototype.XMLPI = function() { + return this.getToken(PostgreSQLParser.XMLPI, 0); +}; + +Func_expr_common_subexprContext.prototype.XMLROOT = function() { + return this.getToken(PostgreSQLParser.XMLROOT, 0); +}; + +Func_expr_common_subexprContext.prototype.XML_P = function() { + return this.getToken(PostgreSQLParser.XML_P, 0); +}; + +Func_expr_common_subexprContext.prototype.xml_root_version = function() { + return this.getTypedRuleContext(Xml_root_versionContext,0); +}; + +Func_expr_common_subexprContext.prototype.opt_xml_root_standalone = function() { + return this.getTypedRuleContext(Opt_xml_root_standaloneContext,0); +}; + +Func_expr_common_subexprContext.prototype.XMLSERIALIZE = function() { + return this.getToken(PostgreSQLParser.XMLSERIALIZE, 0); +}; + +Func_expr_common_subexprContext.prototype.simpletypename = function() { + return this.getTypedRuleContext(SimpletypenameContext,0); +}; + +Func_expr_common_subexprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_expr_common_subexpr(this); + } +}; + +Func_expr_common_subexprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_expr_common_subexpr(this); + } +}; + +Func_expr_common_subexprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_expr_common_subexpr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_expr_common_subexprContext = Func_expr_common_subexprContext; + +PostgreSQLParser.prototype.func_expr_common_subexpr = function() { + + var localctx = new Func_expr_common_subexprContext(this, this._ctx, this.state); + this.enterRule(localctx, 1204, PostgreSQLParser.RULE_func_expr_common_subexpr); + var _la = 0; // Token type + try { + this.state = 9157; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.COLLATION: + this.enterOuterAlt(localctx, 1); + this.state = 8980; + this.match(PostgreSQLParser.COLLATION); + this.state = 8981; + this.match(PostgreSQLParser.FOR); + this.state = 8982; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8983; + this.a_expr(); + this.state = 8984; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.CURRENT_DATE: + this.enterOuterAlt(localctx, 2); + this.state = 8986; + this.match(PostgreSQLParser.CURRENT_DATE); + break; + case PostgreSQLParser.CURRENT_TIME: + this.enterOuterAlt(localctx, 3); + this.state = 8987; + this.match(PostgreSQLParser.CURRENT_TIME); + this.state = 8992; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,561,this._ctx); + if(la_===1) { + this.state = 8988; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8989; + this.iconst(); + this.state = 8990; + this.match(PostgreSQLParser.CLOSE_PAREN); + + } + break; + case PostgreSQLParser.CURRENT_TIMESTAMP: + this.enterOuterAlt(localctx, 4); + this.state = 8994; + this.match(PostgreSQLParser.CURRENT_TIMESTAMP); + this.state = 8999; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,562,this._ctx); + if(la_===1) { + this.state = 8995; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 8996; + this.iconst(); + this.state = 8997; + this.match(PostgreSQLParser.CLOSE_PAREN); + + } + break; + case PostgreSQLParser.LOCALTIME: + this.enterOuterAlt(localctx, 5); + this.state = 9001; + this.match(PostgreSQLParser.LOCALTIME); + this.state = 9006; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,563,this._ctx); + if(la_===1) { + this.state = 9002; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9003; + this.iconst(); + this.state = 9004; + this.match(PostgreSQLParser.CLOSE_PAREN); + + } + break; + case PostgreSQLParser.LOCALTIMESTAMP: + this.enterOuterAlt(localctx, 6); + this.state = 9008; + this.match(PostgreSQLParser.LOCALTIMESTAMP); + this.state = 9013; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,564,this._ctx); + if(la_===1) { + this.state = 9009; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9010; + this.iconst(); + this.state = 9011; + this.match(PostgreSQLParser.CLOSE_PAREN); + + } + break; + case PostgreSQLParser.CURRENT_ROLE: + this.enterOuterAlt(localctx, 7); + this.state = 9015; + this.match(PostgreSQLParser.CURRENT_ROLE); + break; + case PostgreSQLParser.CURRENT_USER: + this.enterOuterAlt(localctx, 8); + this.state = 9016; + this.match(PostgreSQLParser.CURRENT_USER); + break; + case PostgreSQLParser.SESSION_USER: + this.enterOuterAlt(localctx, 9); + this.state = 9017; + this.match(PostgreSQLParser.SESSION_USER); + break; + case PostgreSQLParser.USER: + this.enterOuterAlt(localctx, 10); + this.state = 9018; + this.match(PostgreSQLParser.USER); + break; + case PostgreSQLParser.CURRENT_CATALOG: + this.enterOuterAlt(localctx, 11); + this.state = 9019; + this.match(PostgreSQLParser.CURRENT_CATALOG); + break; + case PostgreSQLParser.CURRENT_SCHEMA: + this.enterOuterAlt(localctx, 12); + this.state = 9020; + this.match(PostgreSQLParser.CURRENT_SCHEMA); + break; + case PostgreSQLParser.CAST: + this.enterOuterAlt(localctx, 13); + this.state = 9021; + this.match(PostgreSQLParser.CAST); + this.state = 9022; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9023; + this.a_expr(); + this.state = 9024; + this.match(PostgreSQLParser.AS); + this.state = 9025; + this.typename(); + this.state = 9026; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.EXTRACT: + this.enterOuterAlt(localctx, 14); + this.state = 9028; + this.match(PostgreSQLParser.EXTRACT); + this.state = 9029; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9030; + this.extract_list(); + this.state = 9031; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.NORMALIZE: + this.enterOuterAlt(localctx, 15); + this.state = 9033; + this.match(PostgreSQLParser.NORMALIZE); + this.state = 9034; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9035; + this.a_expr(); + this.state = 9038; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.COMMA) { + this.state = 9036; + this.match(PostgreSQLParser.COMMA); + this.state = 9037; + this.unicode_normal_form(); + } + + this.state = 9040; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.OVERLAY: + this.enterOuterAlt(localctx, 16); + this.state = 9042; + this.match(PostgreSQLParser.OVERLAY); + this.state = 9043; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9044; + this.overlay_list(); + this.state = 9045; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.POSITION: + this.enterOuterAlt(localctx, 17); + this.state = 9047; + this.match(PostgreSQLParser.POSITION); + this.state = 9048; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9049; + this.position_list(); + this.state = 9050; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.SUBSTRING: + this.enterOuterAlt(localctx, 18); + this.state = 9052; + this.match(PostgreSQLParser.SUBSTRING); + this.state = 9053; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9054; + this.substr_list(); + this.state = 9055; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.TREAT: + this.enterOuterAlt(localctx, 19); + this.state = 9057; + this.match(PostgreSQLParser.TREAT); + this.state = 9058; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9059; + this.a_expr(); + this.state = 9060; + this.match(PostgreSQLParser.AS); + this.state = 9061; + this.typename(); + this.state = 9062; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.TRIM: + this.enterOuterAlt(localctx, 20); + this.state = 9064; + this.match(PostgreSQLParser.TRIM); + this.state = 9065; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9067; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.BOTH || _la===PostgreSQLParser.LEADING || _la===PostgreSQLParser.TRAILING) { + this.state = 9066; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.BOTH || _la===PostgreSQLParser.LEADING || _la===PostgreSQLParser.TRAILING)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } + + this.state = 9069; + this.trim_list(); + this.state = 9070; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.NULLIF: + this.enterOuterAlt(localctx, 21); + this.state = 9072; + this.match(PostgreSQLParser.NULLIF); + this.state = 9073; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9074; + this.a_expr(); + this.state = 9075; + this.match(PostgreSQLParser.COMMA); + this.state = 9076; + this.a_expr(); + this.state = 9077; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.COALESCE: + this.enterOuterAlt(localctx, 22); + this.state = 9079; + this.match(PostgreSQLParser.COALESCE); + this.state = 9080; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9081; + this.expr_list(); + this.state = 9082; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.GREATEST: + this.enterOuterAlt(localctx, 23); + this.state = 9084; + this.match(PostgreSQLParser.GREATEST); + this.state = 9085; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9086; + this.expr_list(); + this.state = 9087; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.LEAST: + this.enterOuterAlt(localctx, 24); + this.state = 9089; + this.match(PostgreSQLParser.LEAST); + this.state = 9090; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9091; + this.expr_list(); + this.state = 9092; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.XMLCONCAT: + this.enterOuterAlt(localctx, 25); + this.state = 9094; + this.match(PostgreSQLParser.XMLCONCAT); + this.state = 9095; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9096; + this.expr_list(); + this.state = 9097; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.XMLELEMENT: + this.enterOuterAlt(localctx, 26); + this.state = 9099; + this.match(PostgreSQLParser.XMLELEMENT); + this.state = 9100; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9101; + this.match(PostgreSQLParser.NAME_P); + this.state = 9102; + this.collabel(); + this.state = 9108; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.COMMA) { + this.state = 9103; + this.match(PostgreSQLParser.COMMA); + this.state = 9106; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,567,this._ctx); + switch(la_) { + case 1: + this.state = 9104; + this.xml_attributes(); + break; + + case 2: + this.state = 9105; + this.expr_list(); + break; + + } + } + + this.state = 9110; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.XMLEXISTS: + this.enterOuterAlt(localctx, 27); + this.state = 9112; + this.match(PostgreSQLParser.XMLEXISTS); + this.state = 9113; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9114; + this.c_expr(); + this.state = 9115; + this.xmlexists_argument(); + this.state = 9116; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.XMLFOREST: + this.enterOuterAlt(localctx, 28); + this.state = 9118; + this.match(PostgreSQLParser.XMLFOREST); + this.state = 9119; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9120; + this.xml_attribute_list(); + this.state = 9121; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.XMLPARSE: + this.enterOuterAlt(localctx, 29); + this.state = 9123; + this.match(PostgreSQLParser.XMLPARSE); + this.state = 9124; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9125; + this.document_or_content(); + this.state = 9126; + this.a_expr(); + this.state = 9127; + this.xml_whitespace_option(); + this.state = 9128; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.XMLPI: + this.enterOuterAlt(localctx, 30); + this.state = 9130; + this.match(PostgreSQLParser.XMLPI); + this.state = 9131; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9132; + this.match(PostgreSQLParser.NAME_P); + this.state = 9133; + this.collabel(); + this.state = 9136; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.COMMA) { + this.state = 9134; + this.match(PostgreSQLParser.COMMA); + this.state = 9135; + this.a_expr(); + } + + this.state = 9138; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.XMLROOT: + this.enterOuterAlt(localctx, 31); + this.state = 9140; + this.match(PostgreSQLParser.XMLROOT); + this.state = 9141; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9142; + this.match(PostgreSQLParser.XML_P); + this.state = 9143; + this.a_expr(); + this.state = 9144; + this.match(PostgreSQLParser.COMMA); + this.state = 9145; + this.xml_root_version(); + this.state = 9146; + this.opt_xml_root_standalone(); + this.state = 9147; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.XMLSERIALIZE: + this.enterOuterAlt(localctx, 32); + this.state = 9149; + this.match(PostgreSQLParser.XMLSERIALIZE); + this.state = 9150; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9151; + this.document_or_content(); + this.state = 9152; + this.a_expr(); + this.state = 9153; + this.match(PostgreSQLParser.AS); + this.state = 9154; + this.simpletypename(); + this.state = 9155; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xml_root_versionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xml_root_version; + return this; +} + +Xml_root_versionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xml_root_versionContext.prototype.constructor = Xml_root_versionContext; + +Xml_root_versionContext.prototype.VERSION_P = function() { + return this.getToken(PostgreSQLParser.VERSION_P, 0); +}; + +Xml_root_versionContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Xml_root_versionContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Xml_root_versionContext.prototype.VALUE_P = function() { + return this.getToken(PostgreSQLParser.VALUE_P, 0); +}; + +Xml_root_versionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXml_root_version(this); + } +}; + +Xml_root_versionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXml_root_version(this); + } +}; + +Xml_root_versionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXml_root_version(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xml_root_versionContext = Xml_root_versionContext; + +PostgreSQLParser.prototype.xml_root_version = function() { + + var localctx = new Xml_root_versionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1206, PostgreSQLParser.RULE_xml_root_version); + try { + this.state = 9164; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,571,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9159; + this.match(PostgreSQLParser.VERSION_P); + this.state = 9160; + this.a_expr(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9161; + this.match(PostgreSQLParser.VERSION_P); + this.state = 9162; + this.match(PostgreSQLParser.NO); + this.state = 9163; + this.match(PostgreSQLParser.VALUE_P); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_xml_root_standaloneContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_xml_root_standalone; + return this; +} + +Opt_xml_root_standaloneContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_xml_root_standaloneContext.prototype.constructor = Opt_xml_root_standaloneContext; + +Opt_xml_root_standaloneContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +Opt_xml_root_standaloneContext.prototype.STANDALONE_P = function() { + return this.getToken(PostgreSQLParser.STANDALONE_P, 0); +}; + +Opt_xml_root_standaloneContext.prototype.YES_P = function() { + return this.getToken(PostgreSQLParser.YES_P, 0); +}; + +Opt_xml_root_standaloneContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Opt_xml_root_standaloneContext.prototype.VALUE_P = function() { + return this.getToken(PostgreSQLParser.VALUE_P, 0); +}; + +Opt_xml_root_standaloneContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_xml_root_standalone(this); + } +}; + +Opt_xml_root_standaloneContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_xml_root_standalone(this); + } +}; + +Opt_xml_root_standaloneContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_xml_root_standalone(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_xml_root_standaloneContext = Opt_xml_root_standaloneContext; + +PostgreSQLParser.prototype.opt_xml_root_standalone = function() { + + var localctx = new Opt_xml_root_standaloneContext(this, this._ctx, this.state); + this.enterRule(localctx, 1208, PostgreSQLParser.RULE_opt_xml_root_standalone); + try { + this.state = 9177; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,572,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9166; + this.match(PostgreSQLParser.COMMA); + this.state = 9167; + this.match(PostgreSQLParser.STANDALONE_P); + this.state = 9168; + this.match(PostgreSQLParser.YES_P); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9169; + this.match(PostgreSQLParser.COMMA); + this.state = 9170; + this.match(PostgreSQLParser.STANDALONE_P); + this.state = 9171; + this.match(PostgreSQLParser.NO); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9172; + this.match(PostgreSQLParser.COMMA); + this.state = 9173; + this.match(PostgreSQLParser.STANDALONE_P); + this.state = 9174; + this.match(PostgreSQLParser.NO); + this.state = 9175; + this.match(PostgreSQLParser.VALUE_P); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xml_attributesContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xml_attributes; + return this; +} + +Xml_attributesContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xml_attributesContext.prototype.constructor = Xml_attributesContext; + +Xml_attributesContext.prototype.XMLATTRIBUTES = function() { + return this.getToken(PostgreSQLParser.XMLATTRIBUTES, 0); +}; + +Xml_attributesContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Xml_attributesContext.prototype.xml_attribute_list = function() { + return this.getTypedRuleContext(Xml_attribute_listContext,0); +}; + +Xml_attributesContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Xml_attributesContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXml_attributes(this); + } +}; + +Xml_attributesContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXml_attributes(this); + } +}; + +Xml_attributesContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXml_attributes(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xml_attributesContext = Xml_attributesContext; + +PostgreSQLParser.prototype.xml_attributes = function() { + + var localctx = new Xml_attributesContext(this, this._ctx, this.state); + this.enterRule(localctx, 1210, PostgreSQLParser.RULE_xml_attributes); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9179; + this.match(PostgreSQLParser.XMLATTRIBUTES); + this.state = 9180; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9181; + this.xml_attribute_list(); + this.state = 9182; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xml_attribute_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xml_attribute_list; + return this; +} + +Xml_attribute_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xml_attribute_listContext.prototype.constructor = Xml_attribute_listContext; + +Xml_attribute_listContext.prototype.xml_attribute_el = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Xml_attribute_elContext); + } else { + return this.getTypedRuleContext(Xml_attribute_elContext,i); + } +}; + +Xml_attribute_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Xml_attribute_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXml_attribute_list(this); + } +}; + +Xml_attribute_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXml_attribute_list(this); + } +}; + +Xml_attribute_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXml_attribute_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xml_attribute_listContext = Xml_attribute_listContext; + +PostgreSQLParser.prototype.xml_attribute_list = function() { + + var localctx = new Xml_attribute_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1212, PostgreSQLParser.RULE_xml_attribute_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9184; + this.xml_attribute_el(); + this.state = 9189; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 9185; + this.match(PostgreSQLParser.COMMA); + this.state = 9186; + this.xml_attribute_el(); + this.state = 9191; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xml_attribute_elContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xml_attribute_el; + return this; +} + +Xml_attribute_elContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xml_attribute_elContext.prototype.constructor = Xml_attribute_elContext; + +Xml_attribute_elContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Xml_attribute_elContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Xml_attribute_elContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +Xml_attribute_elContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXml_attribute_el(this); + } +}; + +Xml_attribute_elContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXml_attribute_el(this); + } +}; + +Xml_attribute_elContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXml_attribute_el(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xml_attribute_elContext = Xml_attribute_elContext; + +PostgreSQLParser.prototype.xml_attribute_el = function() { + + var localctx = new Xml_attribute_elContext(this, this._ctx, this.state); + this.enterRule(localctx, 1214, PostgreSQLParser.RULE_xml_attribute_el); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9192; + this.a_expr(); + this.state = 9195; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.AS) { + this.state = 9193; + this.match(PostgreSQLParser.AS); + this.state = 9194; + this.collabel(); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Document_or_contentContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_document_or_content; + return this; +} + +Document_or_contentContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Document_or_contentContext.prototype.constructor = Document_or_contentContext; + +Document_or_contentContext.prototype.DOCUMENT_P = function() { + return this.getToken(PostgreSQLParser.DOCUMENT_P, 0); +}; + +Document_or_contentContext.prototype.CONTENT_P = function() { + return this.getToken(PostgreSQLParser.CONTENT_P, 0); +}; + +Document_or_contentContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDocument_or_content(this); + } +}; + +Document_or_contentContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDocument_or_content(this); + } +}; + +Document_or_contentContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDocument_or_content(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Document_or_contentContext = Document_or_contentContext; + +PostgreSQLParser.prototype.document_or_content = function() { + + var localctx = new Document_or_contentContext(this, this._ctx, this.state); + this.enterRule(localctx, 1216, PostgreSQLParser.RULE_document_or_content); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9197; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.CONTENT_P || _la===PostgreSQLParser.DOCUMENT_P)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xml_whitespace_optionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xml_whitespace_option; + return this; +} + +Xml_whitespace_optionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xml_whitespace_optionContext.prototype.constructor = Xml_whitespace_optionContext; + +Xml_whitespace_optionContext.prototype.PRESERVE = function() { + return this.getToken(PostgreSQLParser.PRESERVE, 0); +}; + +Xml_whitespace_optionContext.prototype.WHITESPACE_P = function() { + return this.getToken(PostgreSQLParser.WHITESPACE_P, 0); +}; + +Xml_whitespace_optionContext.prototype.STRIP_P = function() { + return this.getToken(PostgreSQLParser.STRIP_P, 0); +}; + +Xml_whitespace_optionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXml_whitespace_option(this); + } +}; + +Xml_whitespace_optionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXml_whitespace_option(this); + } +}; + +Xml_whitespace_optionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXml_whitespace_option(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xml_whitespace_optionContext = Xml_whitespace_optionContext; + +PostgreSQLParser.prototype.xml_whitespace_option = function() { + + var localctx = new Xml_whitespace_optionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1218, PostgreSQLParser.RULE_xml_whitespace_option); + try { + this.state = 9204; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.PRESERVE: + this.enterOuterAlt(localctx, 1); + this.state = 9199; + this.match(PostgreSQLParser.PRESERVE); + this.state = 9200; + this.match(PostgreSQLParser.WHITESPACE_P); + break; + case PostgreSQLParser.STRIP_P: + this.enterOuterAlt(localctx, 2); + this.state = 9201; + this.match(PostgreSQLParser.STRIP_P); + this.state = 9202; + this.match(PostgreSQLParser.WHITESPACE_P); + break; + case PostgreSQLParser.CLOSE_PAREN: + this.enterOuterAlt(localctx, 3); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xmlexists_argumentContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xmlexists_argument; + return this; +} + +Xmlexists_argumentContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xmlexists_argumentContext.prototype.constructor = Xmlexists_argumentContext; + +Xmlexists_argumentContext.prototype.PASSING = function() { + return this.getToken(PostgreSQLParser.PASSING, 0); +}; + +Xmlexists_argumentContext.prototype.c_expr = function() { + return this.getTypedRuleContext(C_exprContext,0); +}; + +Xmlexists_argumentContext.prototype.xml_passing_mech = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Xml_passing_mechContext); + } else { + return this.getTypedRuleContext(Xml_passing_mechContext,i); + } +}; + +Xmlexists_argumentContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXmlexists_argument(this); + } +}; + +Xmlexists_argumentContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXmlexists_argument(this); + } +}; + +Xmlexists_argumentContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXmlexists_argument(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xmlexists_argumentContext = Xmlexists_argumentContext; + +PostgreSQLParser.prototype.xmlexists_argument = function() { + + var localctx = new Xmlexists_argumentContext(this, this._ctx, this.state); + this.enterRule(localctx, 1220, PostgreSQLParser.RULE_xmlexists_argument); + try { + this.state = 9221; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,576,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9206; + this.match(PostgreSQLParser.PASSING); + this.state = 9207; + this.c_expr(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9208; + this.match(PostgreSQLParser.PASSING); + this.state = 9209; + this.c_expr(); + this.state = 9210; + this.xml_passing_mech(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9212; + this.match(PostgreSQLParser.PASSING); + this.state = 9213; + this.xml_passing_mech(); + this.state = 9214; + this.c_expr(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9216; + this.match(PostgreSQLParser.PASSING); + this.state = 9217; + this.xml_passing_mech(); + this.state = 9218; + this.c_expr(); + this.state = 9219; + this.xml_passing_mech(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Xml_passing_mechContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xml_passing_mech; + return this; +} + +Xml_passing_mechContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Xml_passing_mechContext.prototype.constructor = Xml_passing_mechContext; + +Xml_passing_mechContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Xml_passing_mechContext.prototype.REF = function() { + return this.getToken(PostgreSQLParser.REF, 0); +}; + +Xml_passing_mechContext.prototype.VALUE_P = function() { + return this.getToken(PostgreSQLParser.VALUE_P, 0); +}; + +Xml_passing_mechContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXml_passing_mech(this); + } +}; + +Xml_passing_mechContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXml_passing_mech(this); + } +}; + +Xml_passing_mechContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXml_passing_mech(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Xml_passing_mechContext = Xml_passing_mechContext; + +PostgreSQLParser.prototype.xml_passing_mech = function() { + + var localctx = new Xml_passing_mechContext(this, this._ctx, this.state); + this.enterRule(localctx, 1222, PostgreSQLParser.RULE_xml_passing_mech); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9223; + this.match(PostgreSQLParser.BY); + this.state = 9224; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.REF || _la===PostgreSQLParser.VALUE_P)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Within_group_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_within_group_clause; + return this; +} + +Within_group_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Within_group_clauseContext.prototype.constructor = Within_group_clauseContext; + +Within_group_clauseContext.prototype.WITHIN = function() { + return this.getToken(PostgreSQLParser.WITHIN, 0); +}; + +Within_group_clauseContext.prototype.GROUP_P = function() { + return this.getToken(PostgreSQLParser.GROUP_P, 0); +}; + +Within_group_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Within_group_clauseContext.prototype.sort_clause = function() { + return this.getTypedRuleContext(Sort_clauseContext,0); +}; + +Within_group_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Within_group_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterWithin_group_clause(this); + } +}; + +Within_group_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitWithin_group_clause(this); + } +}; + +Within_group_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitWithin_group_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Within_group_clauseContext = Within_group_clauseContext; + +PostgreSQLParser.prototype.within_group_clause = function() { + + var localctx = new Within_group_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1224, PostgreSQLParser.RULE_within_group_clause); + try { + this.state = 9233; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,577,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9226; + this.match(PostgreSQLParser.WITHIN); + this.state = 9227; + this.match(PostgreSQLParser.GROUP_P); + this.state = 9228; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9229; + this.sort_clause(); + this.state = 9230; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Filter_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_filter_clause; + return this; +} + +Filter_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Filter_clauseContext.prototype.constructor = Filter_clauseContext; + +Filter_clauseContext.prototype.FILTER = function() { + return this.getToken(PostgreSQLParser.FILTER, 0); +}; + +Filter_clauseContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Filter_clauseContext.prototype.WHERE = function() { + return this.getToken(PostgreSQLParser.WHERE, 0); +}; + +Filter_clauseContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Filter_clauseContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Filter_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFilter_clause(this); + } +}; + +Filter_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFilter_clause(this); + } +}; + +Filter_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFilter_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Filter_clauseContext = Filter_clauseContext; + +PostgreSQLParser.prototype.filter_clause = function() { + + var localctx = new Filter_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1226, PostgreSQLParser.RULE_filter_clause); + try { + this.state = 9242; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,578,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9235; + this.match(PostgreSQLParser.FILTER); + this.state = 9236; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9237; + this.match(PostgreSQLParser.WHERE); + this.state = 9238; + this.a_expr(); + this.state = 9239; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Window_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_window_clause; + return this; +} + +Window_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Window_clauseContext.prototype.constructor = Window_clauseContext; + +Window_clauseContext.prototype.WINDOW = function() { + return this.getToken(PostgreSQLParser.WINDOW, 0); +}; + +Window_clauseContext.prototype.window_definition_list = function() { + return this.getTypedRuleContext(Window_definition_listContext,0); +}; + +Window_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterWindow_clause(this); + } +}; + +Window_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitWindow_clause(this); + } +}; + +Window_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitWindow_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Window_clauseContext = Window_clauseContext; + +PostgreSQLParser.prototype.window_clause = function() { + + var localctx = new Window_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1228, PostgreSQLParser.RULE_window_clause); + try { + this.state = 9247; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.WINDOW: + this.enterOuterAlt(localctx, 1); + this.state = 9244; + this.match(PostgreSQLParser.WINDOW); + this.state = 9245; + this.window_definition_list(); + break; + case PostgreSQLParser.EOF: + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.COMMA: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.DO: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.INTO: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.THEN: + case PostgreSQLParser.UNION: + case PostgreSQLParser.USING: + case PostgreSQLParser.WHEN: + case PostgreSQLParser.WITH: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COPY: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RESET: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.START: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.CALL: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.LOOP: + case PostgreSQLParser.MetaCommand: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Window_definition_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_window_definition_list; + return this; +} + +Window_definition_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Window_definition_listContext.prototype.constructor = Window_definition_listContext; + +Window_definition_listContext.prototype.window_definition = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Window_definitionContext); + } else { + return this.getTypedRuleContext(Window_definitionContext,i); + } +}; + +Window_definition_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Window_definition_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterWindow_definition_list(this); + } +}; + +Window_definition_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitWindow_definition_list(this); + } +}; + +Window_definition_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitWindow_definition_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Window_definition_listContext = Window_definition_listContext; + +PostgreSQLParser.prototype.window_definition_list = function() { + + var localctx = new Window_definition_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1230, PostgreSQLParser.RULE_window_definition_list); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9249; + this.window_definition(); + this.state = 9254; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,580,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 9250; + this.match(PostgreSQLParser.COMMA); + this.state = 9251; + this.window_definition(); + } + this.state = 9256; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,580,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Window_definitionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_window_definition; + return this; +} + +Window_definitionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Window_definitionContext.prototype.constructor = Window_definitionContext; + +Window_definitionContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Window_definitionContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Window_definitionContext.prototype.window_specification = function() { + return this.getTypedRuleContext(Window_specificationContext,0); +}; + +Window_definitionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterWindow_definition(this); + } +}; + +Window_definitionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitWindow_definition(this); + } +}; + +Window_definitionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitWindow_definition(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Window_definitionContext = Window_definitionContext; + +PostgreSQLParser.prototype.window_definition = function() { + + var localctx = new Window_definitionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1232, PostgreSQLParser.RULE_window_definition); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9257; + this.colid(); + this.state = 9258; + this.match(PostgreSQLParser.AS); + this.state = 9259; + this.window_specification(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Over_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_over_clause; + return this; +} + +Over_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Over_clauseContext.prototype.constructor = Over_clauseContext; + +Over_clauseContext.prototype.OVER = function() { + return this.getToken(PostgreSQLParser.OVER, 0); +}; + +Over_clauseContext.prototype.window_specification = function() { + return this.getTypedRuleContext(Window_specificationContext,0); +}; + +Over_clauseContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Over_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOver_clause(this); + } +}; + +Over_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOver_clause(this); + } +}; + +Over_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOver_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Over_clauseContext = Over_clauseContext; + +PostgreSQLParser.prototype.over_clause = function() { + + var localctx = new Over_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1234, PostgreSQLParser.RULE_over_clause); + try { + this.state = 9267; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,582,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9261; + this.match(PostgreSQLParser.OVER); + this.state = 9264; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + this.state = 9262; + this.window_specification(); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.state = 9263; + this.colid(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Window_specificationContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_window_specification; + return this; +} + +Window_specificationContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Window_specificationContext.prototype.constructor = Window_specificationContext; + +Window_specificationContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Window_specificationContext.prototype.opt_existing_window_name = function() { + return this.getTypedRuleContext(Opt_existing_window_nameContext,0); +}; + +Window_specificationContext.prototype.opt_partition_clause = function() { + return this.getTypedRuleContext(Opt_partition_clauseContext,0); +}; + +Window_specificationContext.prototype.opt_sort_clause = function() { + return this.getTypedRuleContext(Opt_sort_clauseContext,0); +}; + +Window_specificationContext.prototype.opt_frame_clause = function() { + return this.getTypedRuleContext(Opt_frame_clauseContext,0); +}; + +Window_specificationContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Window_specificationContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterWindow_specification(this); + } +}; + +Window_specificationContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitWindow_specification(this); + } +}; + +Window_specificationContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitWindow_specification(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Window_specificationContext = Window_specificationContext; + +PostgreSQLParser.prototype.window_specification = function() { + + var localctx = new Window_specificationContext(this, this._ctx, this.state); + this.enterRule(localctx, 1236, PostgreSQLParser.RULE_window_specification); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9269; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9270; + this.opt_existing_window_name(); + this.state = 9271; + this.opt_partition_clause(); + this.state = 9272; + this.opt_sort_clause(); + this.state = 9273; + this.opt_frame_clause(); + this.state = 9274; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_existing_window_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_existing_window_name; + return this; +} + +Opt_existing_window_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_existing_window_nameContext.prototype.constructor = Opt_existing_window_nameContext; + +Opt_existing_window_nameContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Opt_existing_window_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_existing_window_name(this); + } +}; + +Opt_existing_window_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_existing_window_name(this); + } +}; + +Opt_existing_window_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_existing_window_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_existing_window_nameContext = Opt_existing_window_nameContext; + +PostgreSQLParser.prototype.opt_existing_window_name = function() { + + var localctx = new Opt_existing_window_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1238, PostgreSQLParser.RULE_opt_existing_window_name); + try { + this.state = 9278; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,583,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9276; + this.colid(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_partition_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_partition_clause; + return this; +} + +Opt_partition_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_partition_clauseContext.prototype.constructor = Opt_partition_clauseContext; + +Opt_partition_clauseContext.prototype.PARTITION = function() { + return this.getToken(PostgreSQLParser.PARTITION, 0); +}; + +Opt_partition_clauseContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Opt_partition_clauseContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Opt_partition_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_partition_clause(this); + } +}; + +Opt_partition_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_partition_clause(this); + } +}; + +Opt_partition_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_partition_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_partition_clauseContext = Opt_partition_clauseContext; + +PostgreSQLParser.prototype.opt_partition_clause = function() { + + var localctx = new Opt_partition_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1240, PostgreSQLParser.RULE_opt_partition_clause); + try { + this.state = 9284; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.PARTITION: + this.enterOuterAlt(localctx, 1); + this.state = 9280; + this.match(PostgreSQLParser.PARTITION); + this.state = 9281; + this.match(PostgreSQLParser.BY); + this.state = 9282; + this.expr_list(); + break; + case PostgreSQLParser.CLOSE_PAREN: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.GROUPS: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_frame_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_frame_clause; + return this; +} + +Opt_frame_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_frame_clauseContext.prototype.constructor = Opt_frame_clauseContext; + +Opt_frame_clauseContext.prototype.RANGE = function() { + return this.getToken(PostgreSQLParser.RANGE, 0); +}; + +Opt_frame_clauseContext.prototype.frame_extent = function() { + return this.getTypedRuleContext(Frame_extentContext,0); +}; + +Opt_frame_clauseContext.prototype.opt_window_exclusion_clause = function() { + return this.getTypedRuleContext(Opt_window_exclusion_clauseContext,0); +}; + +Opt_frame_clauseContext.prototype.ROWS = function() { + return this.getToken(PostgreSQLParser.ROWS, 0); +}; + +Opt_frame_clauseContext.prototype.GROUPS = function() { + return this.getToken(PostgreSQLParser.GROUPS, 0); +}; + +Opt_frame_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_frame_clause(this); + } +}; + +Opt_frame_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_frame_clause(this); + } +}; + +Opt_frame_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_frame_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_frame_clauseContext = Opt_frame_clauseContext; + +PostgreSQLParser.prototype.opt_frame_clause = function() { + + var localctx = new Opt_frame_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1242, PostgreSQLParser.RULE_opt_frame_clause); + try { + this.state = 9299; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.RANGE: + this.enterOuterAlt(localctx, 1); + this.state = 9286; + this.match(PostgreSQLParser.RANGE); + this.state = 9287; + this.frame_extent(); + this.state = 9288; + this.opt_window_exclusion_clause(); + break; + case PostgreSQLParser.ROWS: + this.enterOuterAlt(localctx, 2); + this.state = 9290; + this.match(PostgreSQLParser.ROWS); + this.state = 9291; + this.frame_extent(); + this.state = 9292; + this.opt_window_exclusion_clause(); + break; + case PostgreSQLParser.GROUPS: + this.enterOuterAlt(localctx, 3); + this.state = 9294; + this.match(PostgreSQLParser.GROUPS); + this.state = 9295; + this.frame_extent(); + this.state = 9296; + this.opt_window_exclusion_clause(); + break; + case PostgreSQLParser.CLOSE_PAREN: + this.enterOuterAlt(localctx, 4); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Frame_extentContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_frame_extent; + return this; +} + +Frame_extentContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Frame_extentContext.prototype.constructor = Frame_extentContext; + +Frame_extentContext.prototype.frame_bound = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Frame_boundContext); + } else { + return this.getTypedRuleContext(Frame_boundContext,i); + } +}; + +Frame_extentContext.prototype.BETWEEN = function() { + return this.getToken(PostgreSQLParser.BETWEEN, 0); +}; + +Frame_extentContext.prototype.AND = function() { + return this.getToken(PostgreSQLParser.AND, 0); +}; + +Frame_extentContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFrame_extent(this); + } +}; + +Frame_extentContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFrame_extent(this); + } +}; + +Frame_extentContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFrame_extent(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Frame_extentContext = Frame_extentContext; + +PostgreSQLParser.prototype.frame_extent = function() { + + var localctx = new Frame_extentContext(this, this._ctx, this.state); + this.enterRule(localctx, 1244, PostgreSQLParser.RULE_frame_extent); + try { + this.state = 9307; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,586,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9301; + this.frame_bound(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9302; + this.match(PostgreSQLParser.BETWEEN); + this.state = 9303; + this.frame_bound(); + this.state = 9304; + this.match(PostgreSQLParser.AND); + this.state = 9305; + this.frame_bound(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Frame_boundContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_frame_bound; + return this; +} + +Frame_boundContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Frame_boundContext.prototype.constructor = Frame_boundContext; + +Frame_boundContext.prototype.UNBOUNDED = function() { + return this.getToken(PostgreSQLParser.UNBOUNDED, 0); +}; + +Frame_boundContext.prototype.PRECEDING = function() { + return this.getToken(PostgreSQLParser.PRECEDING, 0); +}; + +Frame_boundContext.prototype.FOLLOWING = function() { + return this.getToken(PostgreSQLParser.FOLLOWING, 0); +}; + +Frame_boundContext.prototype.CURRENT_P = function() { + return this.getToken(PostgreSQLParser.CURRENT_P, 0); +}; + +Frame_boundContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +Frame_boundContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Frame_boundContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFrame_bound(this); + } +}; + +Frame_boundContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFrame_bound(this); + } +}; + +Frame_boundContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFrame_bound(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Frame_boundContext = Frame_boundContext; + +PostgreSQLParser.prototype.frame_bound = function() { + + var localctx = new Frame_boundContext(this, this._ctx, this.state); + this.enterRule(localctx, 1246, PostgreSQLParser.RULE_frame_bound); + var _la = 0; // Token type + try { + this.state = 9316; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,587,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9309; + this.match(PostgreSQLParser.UNBOUNDED); + this.state = 9310; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FOLLOWING || _la===PostgreSQLParser.PRECEDING)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9311; + this.match(PostgreSQLParser.CURRENT_P); + this.state = 9312; + this.match(PostgreSQLParser.ROW); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9313; + this.a_expr(); + this.state = 9314; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FOLLOWING || _la===PostgreSQLParser.PRECEDING)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_window_exclusion_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_window_exclusion_clause; + return this; +} + +Opt_window_exclusion_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_window_exclusion_clauseContext.prototype.constructor = Opt_window_exclusion_clauseContext; + +Opt_window_exclusion_clauseContext.prototype.EXCLUDE = function() { + return this.getToken(PostgreSQLParser.EXCLUDE, 0); +}; + +Opt_window_exclusion_clauseContext.prototype.CURRENT_P = function() { + return this.getToken(PostgreSQLParser.CURRENT_P, 0); +}; + +Opt_window_exclusion_clauseContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +Opt_window_exclusion_clauseContext.prototype.GROUP_P = function() { + return this.getToken(PostgreSQLParser.GROUP_P, 0); +}; + +Opt_window_exclusion_clauseContext.prototype.TIES = function() { + return this.getToken(PostgreSQLParser.TIES, 0); +}; + +Opt_window_exclusion_clauseContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Opt_window_exclusion_clauseContext.prototype.OTHERS = function() { + return this.getToken(PostgreSQLParser.OTHERS, 0); +}; + +Opt_window_exclusion_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_window_exclusion_clause(this); + } +}; + +Opt_window_exclusion_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_window_exclusion_clause(this); + } +}; + +Opt_window_exclusion_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_window_exclusion_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_window_exclusion_clauseContext = Opt_window_exclusion_clauseContext; + +PostgreSQLParser.prototype.opt_window_exclusion_clause = function() { + + var localctx = new Opt_window_exclusion_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1248, PostgreSQLParser.RULE_opt_window_exclusion_clause); + try { + this.state = 9328; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.EXCLUDE: + this.enterOuterAlt(localctx, 1); + this.state = 9318; + this.match(PostgreSQLParser.EXCLUDE); + this.state = 9325; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CURRENT_P: + this.state = 9319; + this.match(PostgreSQLParser.CURRENT_P); + this.state = 9320; + this.match(PostgreSQLParser.ROW); + break; + case PostgreSQLParser.GROUP_P: + this.state = 9321; + this.match(PostgreSQLParser.GROUP_P); + break; + case PostgreSQLParser.TIES: + this.state = 9322; + this.match(PostgreSQLParser.TIES); + break; + case PostgreSQLParser.NO: + this.state = 9323; + this.match(PostgreSQLParser.NO); + this.state = 9324; + this.match(PostgreSQLParser.OTHERS); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + case PostgreSQLParser.CLOSE_PAREN: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RowContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_row; + return this; +} + +RowContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RowContext.prototype.constructor = RowContext; + +RowContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +RowContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +RowContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +RowContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +RowContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +RowContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +RowContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRow(this); + } +}; + +RowContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRow(this); + } +}; + +RowContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRow(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RowContext = RowContext; + +PostgreSQLParser.prototype.row = function() { + + var localctx = new RowContext(this, this._ctx, this.state); + this.enterRule(localctx, 1250, PostgreSQLParser.RULE_row); + var _la = 0; // Token type + try { + this.state = 9342; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ROW: + this.enterOuterAlt(localctx, 1); + this.state = 9330; + this.match(PostgreSQLParser.ROW); + this.state = 9331; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9333; + this._errHandler.sync(this); + _la = this._input.LA(1); + if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << PostgreSQLParser.OPEN_PAREN) | (1 << PostgreSQLParser.PLUS) | (1 << PostgreSQLParser.MINUS) | (1 << PostgreSQLParser.PARAM) | (1 << PostgreSQLParser.Operator))) !== 0) || ((((_la - 33)) & ~0x1f) == 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.AND - 33)) | (1 << (PostgreSQLParser.ARRAY - 33)) | (1 << (PostgreSQLParser.CASE - 33)) | (1 << (PostgreSQLParser.CAST - 33)) | (1 << (PostgreSQLParser.COLLATE - 33)) | (1 << (PostgreSQLParser.COLUMN - 33)) | (1 << (PostgreSQLParser.CONSTRAINT - 33)) | (1 << (PostgreSQLParser.CURRENT_CATALOG - 33)) | (1 << (PostgreSQLParser.CURRENT_DATE - 33)) | (1 << (PostgreSQLParser.CURRENT_ROLE - 33)) | (1 << (PostgreSQLParser.CURRENT_TIME - 33)) | (1 << (PostgreSQLParser.CURRENT_TIMESTAMP - 33)) | (1 << (PostgreSQLParser.CURRENT_USER - 33)) | (1 << (PostgreSQLParser.DEFAULT - 33)) | (1 << (PostgreSQLParser.DO - 33)) | (1 << (PostgreSQLParser.FALSE_P - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || ((((_la - 75)) & ~0x1f) == 0 && ((1 << (_la - 75)) & ((1 << (PostgreSQLParser.LOCALTIME - 75)) | (1 << (PostgreSQLParser.LOCALTIMESTAMP - 75)) | (1 << (PostgreSQLParser.NOT - 75)) | (1 << (PostgreSQLParser.NULL_P - 75)) | (1 << (PostgreSQLParser.SESSION_USER - 75)) | (1 << (PostgreSQLParser.TABLE - 75)) | (1 << (PostgreSQLParser.TRUE_P - 75)) | (1 << (PostgreSQLParser.UNIQUE - 75)) | (1 << (PostgreSQLParser.USER - 75)) | (1 << (PostgreSQLParser.AUTHORIZATION - 75)))) !== 0) || ((((_la - 107)) & ~0x1f) == 0 && ((1 << (_la - 107)) & ((1 << (PostgreSQLParser.BINARY - 107)) | (1 << (PostgreSQLParser.COLLATION - 107)) | (1 << (PostgreSQLParser.CONCURRENTLY - 107)) | (1 << (PostgreSQLParser.CROSS - 107)) | (1 << (PostgreSQLParser.CURRENT_SCHEMA - 107)) | (1 << (PostgreSQLParser.FREEZE - 107)) | (1 << (PostgreSQLParser.FULL - 107)) | (1 << (PostgreSQLParser.ILIKE - 107)) | (1 << (PostgreSQLParser.INNER_P - 107)) | (1 << (PostgreSQLParser.IS - 107)) | (1 << (PostgreSQLParser.ISNULL - 107)) | (1 << (PostgreSQLParser.JOIN - 107)) | (1 << (PostgreSQLParser.LEFT - 107)) | (1 << (PostgreSQLParser.LIKE - 107)) | (1 << (PostgreSQLParser.NATURAL - 107)) | (1 << (PostgreSQLParser.NOTNULL - 107)) | (1 << (PostgreSQLParser.OUTER_P - 107)) | (1 << (PostgreSQLParser.OVER - 107)) | (1 << (PostgreSQLParser.OVERLAPS - 107)) | (1 << (PostgreSQLParser.RIGHT - 107)) | (1 << (PostgreSQLParser.SIMILAR - 107)) | (1 << (PostgreSQLParser.VERBOSE - 107)) | (1 << (PostgreSQLParser.ABORT_P - 107)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 107)) | (1 << (PostgreSQLParser.ACCESS - 107)) | (1 << (PostgreSQLParser.ACTION - 107)) | (1 << (PostgreSQLParser.ADD_P - 107)) | (1 << (PostgreSQLParser.ADMIN - 107)) | (1 << (PostgreSQLParser.AFTER - 107)) | (1 << (PostgreSQLParser.AGGREGATE - 107)) | (1 << (PostgreSQLParser.ALSO - 107)) | (1 << (PostgreSQLParser.ALTER - 107)))) !== 0) || ((((_la - 139)) & ~0x1f) == 0 && ((1 << (_la - 139)) & ((1 << (PostgreSQLParser.ALWAYS - 139)) | (1 << (PostgreSQLParser.ASSERTION - 139)) | (1 << (PostgreSQLParser.ASSIGNMENT - 139)) | (1 << (PostgreSQLParser.AT - 139)) | (1 << (PostgreSQLParser.ATTRIBUTE - 139)) | (1 << (PostgreSQLParser.BACKWARD - 139)) | (1 << (PostgreSQLParser.BEFORE - 139)) | (1 << (PostgreSQLParser.BEGIN_P - 139)) | (1 << (PostgreSQLParser.BY - 139)) | (1 << (PostgreSQLParser.CACHE - 139)) | (1 << (PostgreSQLParser.CALLED - 139)) | (1 << (PostgreSQLParser.CASCADE - 139)) | (1 << (PostgreSQLParser.CASCADED - 139)) | (1 << (PostgreSQLParser.CATALOG - 139)) | (1 << (PostgreSQLParser.CHAIN - 139)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 139)) | (1 << (PostgreSQLParser.CHECKPOINT - 139)) | (1 << (PostgreSQLParser.CLASS - 139)) | (1 << (PostgreSQLParser.CLOSE - 139)) | (1 << (PostgreSQLParser.CLUSTER - 139)) | (1 << (PostgreSQLParser.COMMENT - 139)) | (1 << (PostgreSQLParser.COMMENTS - 139)) | (1 << (PostgreSQLParser.COMMIT - 139)) | (1 << (PostgreSQLParser.COMMITTED - 139)) | (1 << (PostgreSQLParser.CONFIGURATION - 139)) | (1 << (PostgreSQLParser.CONNECTION - 139)) | (1 << (PostgreSQLParser.CONSTRAINTS - 139)) | (1 << (PostgreSQLParser.CONTENT_P - 139)) | (1 << (PostgreSQLParser.CONTINUE_P - 139)) | (1 << (PostgreSQLParser.CONVERSION_P - 139)) | (1 << (PostgreSQLParser.COPY - 139)) | (1 << (PostgreSQLParser.COST - 139)))) !== 0) || ((((_la - 171)) & ~0x1f) == 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.CSV - 171)) | (1 << (PostgreSQLParser.CURSOR - 171)) | (1 << (PostgreSQLParser.CYCLE - 171)) | (1 << (PostgreSQLParser.DATA_P - 171)) | (1 << (PostgreSQLParser.DATABASE - 171)) | (1 << (PostgreSQLParser.DAY_P - 171)) | (1 << (PostgreSQLParser.DEALLOCATE - 171)) | (1 << (PostgreSQLParser.DECLARE - 171)) | (1 << (PostgreSQLParser.DEFAULTS - 171)) | (1 << (PostgreSQLParser.DEFERRED - 171)) | (1 << (PostgreSQLParser.DEFINER - 171)) | (1 << (PostgreSQLParser.DELETE_P - 171)) | (1 << (PostgreSQLParser.DELIMITER - 171)) | (1 << (PostgreSQLParser.DELIMITERS - 171)) | (1 << (PostgreSQLParser.DICTIONARY - 171)) | (1 << (PostgreSQLParser.DISABLE_P - 171)) | (1 << (PostgreSQLParser.DISCARD - 171)) | (1 << (PostgreSQLParser.DOCUMENT_P - 171)) | (1 << (PostgreSQLParser.DOMAIN_P - 171)) | (1 << (PostgreSQLParser.DOUBLE_P - 171)) | (1 << (PostgreSQLParser.DROP - 171)) | (1 << (PostgreSQLParser.EACH - 171)) | (1 << (PostgreSQLParser.ENABLE_P - 171)) | (1 << (PostgreSQLParser.ENCODING - 171)) | (1 << (PostgreSQLParser.ENCRYPTED - 171)) | (1 << (PostgreSQLParser.ENUM_P - 171)) | (1 << (PostgreSQLParser.ESCAPE - 171)) | (1 << (PostgreSQLParser.EVENT - 171)) | (1 << (PostgreSQLParser.EXCLUDE - 171)) | (1 << (PostgreSQLParser.EXCLUDING - 171)) | (1 << (PostgreSQLParser.EXCLUSIVE - 171)) | (1 << (PostgreSQLParser.EXECUTE - 171)))) !== 0) || ((((_la - 203)) & ~0x1f) == 0 && ((1 << (_la - 203)) & ((1 << (PostgreSQLParser.EXPLAIN - 203)) | (1 << (PostgreSQLParser.EXTENSION - 203)) | (1 << (PostgreSQLParser.EXTERNAL - 203)) | (1 << (PostgreSQLParser.FAMILY - 203)) | (1 << (PostgreSQLParser.FIRST_P - 203)) | (1 << (PostgreSQLParser.FOLLOWING - 203)) | (1 << (PostgreSQLParser.FORCE - 203)) | (1 << (PostgreSQLParser.FORWARD - 203)) | (1 << (PostgreSQLParser.FUNCTION - 203)) | (1 << (PostgreSQLParser.FUNCTIONS - 203)) | (1 << (PostgreSQLParser.GLOBAL - 203)) | (1 << (PostgreSQLParser.GRANTED - 203)) | (1 << (PostgreSQLParser.HANDLER - 203)) | (1 << (PostgreSQLParser.HEADER_P - 203)) | (1 << (PostgreSQLParser.HOLD - 203)) | (1 << (PostgreSQLParser.HOUR_P - 203)) | (1 << (PostgreSQLParser.IDENTITY_P - 203)) | (1 << (PostgreSQLParser.IF_P - 203)) | (1 << (PostgreSQLParser.IMMEDIATE - 203)) | (1 << (PostgreSQLParser.IMMUTABLE - 203)) | (1 << (PostgreSQLParser.IMPLICIT_P - 203)) | (1 << (PostgreSQLParser.INCLUDING - 203)) | (1 << (PostgreSQLParser.INCREMENT - 203)) | (1 << (PostgreSQLParser.INDEX - 203)) | (1 << (PostgreSQLParser.INDEXES - 203)) | (1 << (PostgreSQLParser.INHERIT - 203)) | (1 << (PostgreSQLParser.INHERITS - 203)) | (1 << (PostgreSQLParser.INLINE_P - 203)) | (1 << (PostgreSQLParser.INSENSITIVE - 203)) | (1 << (PostgreSQLParser.INSERT - 203)) | (1 << (PostgreSQLParser.INSTEAD - 203)) | (1 << (PostgreSQLParser.INVOKER - 203)))) !== 0) || ((((_la - 235)) & ~0x1f) == 0 && ((1 << (_la - 235)) & ((1 << (PostgreSQLParser.ISOLATION - 235)) | (1 << (PostgreSQLParser.KEY - 235)) | (1 << (PostgreSQLParser.LABEL - 235)) | (1 << (PostgreSQLParser.LANGUAGE - 235)) | (1 << (PostgreSQLParser.LARGE_P - 235)) | (1 << (PostgreSQLParser.LAST_P - 235)) | (1 << (PostgreSQLParser.LEAKPROOF - 235)) | (1 << (PostgreSQLParser.LEVEL - 235)) | (1 << (PostgreSQLParser.LISTEN - 235)) | (1 << (PostgreSQLParser.LOAD - 235)) | (1 << (PostgreSQLParser.LOCAL - 235)) | (1 << (PostgreSQLParser.LOCATION - 235)) | (1 << (PostgreSQLParser.LOCK_P - 235)) | (1 << (PostgreSQLParser.MAPPING - 235)) | (1 << (PostgreSQLParser.MATCH - 235)) | (1 << (PostgreSQLParser.MATERIALIZED - 235)) | (1 << (PostgreSQLParser.MAXVALUE - 235)) | (1 << (PostgreSQLParser.MINUTE_P - 235)) | (1 << (PostgreSQLParser.MINVALUE - 235)) | (1 << (PostgreSQLParser.MODE - 235)) | (1 << (PostgreSQLParser.MONTH_P - 235)) | (1 << (PostgreSQLParser.MOVE - 235)) | (1 << (PostgreSQLParser.NAME_P - 235)) | (1 << (PostgreSQLParser.NAMES - 235)) | (1 << (PostgreSQLParser.NEXT - 235)) | (1 << (PostgreSQLParser.NO - 235)) | (1 << (PostgreSQLParser.NOTHING - 235)) | (1 << (PostgreSQLParser.NOTIFY - 235)) | (1 << (PostgreSQLParser.NOWAIT - 235)) | (1 << (PostgreSQLParser.NULLS_P - 235)) | (1 << (PostgreSQLParser.OBJECT_P - 235)) | (1 << (PostgreSQLParser.OF - 235)))) !== 0) || ((((_la - 267)) & ~0x1f) == 0 && ((1 << (_la - 267)) & ((1 << (PostgreSQLParser.OFF - 267)) | (1 << (PostgreSQLParser.OIDS - 267)) | (1 << (PostgreSQLParser.OPERATOR - 267)) | (1 << (PostgreSQLParser.OPTION - 267)) | (1 << (PostgreSQLParser.OPTIONS - 267)) | (1 << (PostgreSQLParser.OWNED - 267)) | (1 << (PostgreSQLParser.OWNER - 267)) | (1 << (PostgreSQLParser.PARSER - 267)) | (1 << (PostgreSQLParser.PARTIAL - 267)) | (1 << (PostgreSQLParser.PARTITION - 267)) | (1 << (PostgreSQLParser.PASSING - 267)) | (1 << (PostgreSQLParser.PASSWORD - 267)) | (1 << (PostgreSQLParser.PLANS - 267)) | (1 << (PostgreSQLParser.PRECEDING - 267)) | (1 << (PostgreSQLParser.PREPARE - 267)) | (1 << (PostgreSQLParser.PREPARED - 267)) | (1 << (PostgreSQLParser.PRESERVE - 267)) | (1 << (PostgreSQLParser.PRIOR - 267)) | (1 << (PostgreSQLParser.PRIVILEGES - 267)) | (1 << (PostgreSQLParser.PROCEDURAL - 267)) | (1 << (PostgreSQLParser.PROCEDURE - 267)) | (1 << (PostgreSQLParser.PROGRAM - 267)) | (1 << (PostgreSQLParser.QUOTE - 267)) | (1 << (PostgreSQLParser.RANGE - 267)) | (1 << (PostgreSQLParser.READ - 267)) | (1 << (PostgreSQLParser.REASSIGN - 267)) | (1 << (PostgreSQLParser.RECHECK - 267)) | (1 << (PostgreSQLParser.RECURSIVE - 267)) | (1 << (PostgreSQLParser.REF - 267)) | (1 << (PostgreSQLParser.REFRESH - 267)) | (1 << (PostgreSQLParser.REINDEX - 267)) | (1 << (PostgreSQLParser.RELATIVE_P - 267)))) !== 0) || ((((_la - 299)) & ~0x1f) == 0 && ((1 << (_la - 299)) & ((1 << (PostgreSQLParser.RELEASE - 299)) | (1 << (PostgreSQLParser.RENAME - 299)) | (1 << (PostgreSQLParser.REPEATABLE - 299)) | (1 << (PostgreSQLParser.REPLACE - 299)) | (1 << (PostgreSQLParser.REPLICA - 299)) | (1 << (PostgreSQLParser.RESET - 299)) | (1 << (PostgreSQLParser.RESTART - 299)) | (1 << (PostgreSQLParser.RESTRICT - 299)) | (1 << (PostgreSQLParser.RETURNS - 299)) | (1 << (PostgreSQLParser.REVOKE - 299)) | (1 << (PostgreSQLParser.ROLE - 299)) | (1 << (PostgreSQLParser.ROLLBACK - 299)) | (1 << (PostgreSQLParser.ROWS - 299)) | (1 << (PostgreSQLParser.RULE - 299)) | (1 << (PostgreSQLParser.SAVEPOINT - 299)) | (1 << (PostgreSQLParser.SCHEMA - 299)) | (1 << (PostgreSQLParser.SCROLL - 299)) | (1 << (PostgreSQLParser.SEARCH - 299)) | (1 << (PostgreSQLParser.SECOND_P - 299)) | (1 << (PostgreSQLParser.SECURITY - 299)) | (1 << (PostgreSQLParser.SEQUENCE - 299)) | (1 << (PostgreSQLParser.SEQUENCES - 299)) | (1 << (PostgreSQLParser.SERIALIZABLE - 299)) | (1 << (PostgreSQLParser.SERVER - 299)) | (1 << (PostgreSQLParser.SESSION - 299)) | (1 << (PostgreSQLParser.SET - 299)) | (1 << (PostgreSQLParser.SHARE - 299)) | (1 << (PostgreSQLParser.SHOW - 299)) | (1 << (PostgreSQLParser.SIMPLE - 299)) | (1 << (PostgreSQLParser.SNAPSHOT - 299)) | (1 << (PostgreSQLParser.STABLE - 299)) | (1 << (PostgreSQLParser.STANDALONE_P - 299)))) !== 0) || ((((_la - 331)) & ~0x1f) == 0 && ((1 << (_la - 331)) & ((1 << (PostgreSQLParser.START - 331)) | (1 << (PostgreSQLParser.STATEMENT - 331)) | (1 << (PostgreSQLParser.STATISTICS - 331)) | (1 << (PostgreSQLParser.STDIN - 331)) | (1 << (PostgreSQLParser.STDOUT - 331)) | (1 << (PostgreSQLParser.STORAGE - 331)) | (1 << (PostgreSQLParser.STRICT_P - 331)) | (1 << (PostgreSQLParser.STRIP_P - 331)) | (1 << (PostgreSQLParser.SYSID - 331)) | (1 << (PostgreSQLParser.SYSTEM_P - 331)) | (1 << (PostgreSQLParser.TABLES - 331)) | (1 << (PostgreSQLParser.TABLESPACE - 331)) | (1 << (PostgreSQLParser.TEMP - 331)) | (1 << (PostgreSQLParser.TEMPLATE - 331)) | (1 << (PostgreSQLParser.TEMPORARY - 331)) | (1 << (PostgreSQLParser.TEXT_P - 331)) | (1 << (PostgreSQLParser.TRANSACTION - 331)) | (1 << (PostgreSQLParser.TRIGGER - 331)) | (1 << (PostgreSQLParser.TRUNCATE - 331)) | (1 << (PostgreSQLParser.TRUSTED - 331)) | (1 << (PostgreSQLParser.TYPE_P - 331)) | (1 << (PostgreSQLParser.TYPES_P - 331)) | (1 << (PostgreSQLParser.UNBOUNDED - 331)) | (1 << (PostgreSQLParser.UNCOMMITTED - 331)) | (1 << (PostgreSQLParser.UNENCRYPTED - 331)) | (1 << (PostgreSQLParser.UNKNOWN - 331)) | (1 << (PostgreSQLParser.UNLISTEN - 331)) | (1 << (PostgreSQLParser.UNLOGGED - 331)) | (1 << (PostgreSQLParser.UNTIL - 331)) | (1 << (PostgreSQLParser.UPDATE - 331)) | (1 << (PostgreSQLParser.VACUUM - 331)) | (1 << (PostgreSQLParser.VALID - 331)))) !== 0) || ((((_la - 363)) & ~0x1f) == 0 && ((1 << (_la - 363)) & ((1 << (PostgreSQLParser.VALIDATE - 363)) | (1 << (PostgreSQLParser.VALIDATOR - 363)) | (1 << (PostgreSQLParser.VARYING - 363)) | (1 << (PostgreSQLParser.VERSION_P - 363)) | (1 << (PostgreSQLParser.VIEW - 363)) | (1 << (PostgreSQLParser.VOLATILE - 363)) | (1 << (PostgreSQLParser.WHITESPACE_P - 363)) | (1 << (PostgreSQLParser.WITHOUT - 363)) | (1 << (PostgreSQLParser.WORK - 363)) | (1 << (PostgreSQLParser.WRAPPER - 363)) | (1 << (PostgreSQLParser.WRITE - 363)) | (1 << (PostgreSQLParser.XML_P - 363)) | (1 << (PostgreSQLParser.YEAR_P - 363)) | (1 << (PostgreSQLParser.YES_P - 363)) | (1 << (PostgreSQLParser.ZONE - 363)) | (1 << (PostgreSQLParser.BETWEEN - 363)) | (1 << (PostgreSQLParser.BIGINT - 363)) | (1 << (PostgreSQLParser.BIT - 363)) | (1 << (PostgreSQLParser.BOOLEAN_P - 363)) | (1 << (PostgreSQLParser.CHAR_P - 363)) | (1 << (PostgreSQLParser.CHARACTER - 363)) | (1 << (PostgreSQLParser.COALESCE - 363)) | (1 << (PostgreSQLParser.DEC - 363)) | (1 << (PostgreSQLParser.DECIMAL_P - 363)) | (1 << (PostgreSQLParser.EXISTS - 363)) | (1 << (PostgreSQLParser.EXTRACT - 363)) | (1 << (PostgreSQLParser.FLOAT_P - 363)) | (1 << (PostgreSQLParser.GREATEST - 363)) | (1 << (PostgreSQLParser.INOUT - 363)) | (1 << (PostgreSQLParser.INT_P - 363)) | (1 << (PostgreSQLParser.INTEGER - 363)) | (1 << (PostgreSQLParser.INTERVAL - 363)))) !== 0) || ((((_la - 395)) & ~0x1f) == 0 && ((1 << (_la - 395)) & ((1 << (PostgreSQLParser.LEAST - 395)) | (1 << (PostgreSQLParser.NATIONAL - 395)) | (1 << (PostgreSQLParser.NCHAR - 395)) | (1 << (PostgreSQLParser.NONE - 395)) | (1 << (PostgreSQLParser.NULLIF - 395)) | (1 << (PostgreSQLParser.NUMERIC - 395)) | (1 << (PostgreSQLParser.OVERLAY - 395)) | (1 << (PostgreSQLParser.POSITION - 395)) | (1 << (PostgreSQLParser.PRECISION - 395)) | (1 << (PostgreSQLParser.REAL - 395)) | (1 << (PostgreSQLParser.ROW - 395)) | (1 << (PostgreSQLParser.SETOF - 395)) | (1 << (PostgreSQLParser.SMALLINT - 395)) | (1 << (PostgreSQLParser.SUBSTRING - 395)) | (1 << (PostgreSQLParser.TIME - 395)) | (1 << (PostgreSQLParser.TIMESTAMP - 395)) | (1 << (PostgreSQLParser.TREAT - 395)) | (1 << (PostgreSQLParser.TRIM - 395)) | (1 << (PostgreSQLParser.VALUES - 395)) | (1 << (PostgreSQLParser.VARCHAR - 395)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 395)) | (1 << (PostgreSQLParser.XMLCONCAT - 395)) | (1 << (PostgreSQLParser.XMLELEMENT - 395)) | (1 << (PostgreSQLParser.XMLEXISTS - 395)) | (1 << (PostgreSQLParser.XMLFOREST - 395)) | (1 << (PostgreSQLParser.XMLPARSE - 395)) | (1 << (PostgreSQLParser.XMLPI - 395)) | (1 << (PostgreSQLParser.XMLROOT - 395)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 395)) | (1 << (PostgreSQLParser.CALL - 395)) | (1 << (PostgreSQLParser.CURRENT_P - 395)) | (1 << (PostgreSQLParser.ATTACH - 395)))) !== 0) || ((((_la - 427)) & ~0x1f) == 0 && ((1 << (_la - 427)) & ((1 << (PostgreSQLParser.DETACH - 427)) | (1 << (PostgreSQLParser.EXPRESSION - 427)) | (1 << (PostgreSQLParser.GENERATED - 427)) | (1 << (PostgreSQLParser.LOGGED - 427)) | (1 << (PostgreSQLParser.STORED - 427)) | (1 << (PostgreSQLParser.INCLUDE - 427)) | (1 << (PostgreSQLParser.ROUTINE - 427)) | (1 << (PostgreSQLParser.TRANSFORM - 427)) | (1 << (PostgreSQLParser.IMPORT_P - 427)) | (1 << (PostgreSQLParser.POLICY - 427)) | (1 << (PostgreSQLParser.METHOD - 427)) | (1 << (PostgreSQLParser.REFERENCING - 427)) | (1 << (PostgreSQLParser.NEW - 427)) | (1 << (PostgreSQLParser.OLD - 427)) | (1 << (PostgreSQLParser.VALUE_P - 427)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 427)) | (1 << (PostgreSQLParser.PUBLICATION - 427)) | (1 << (PostgreSQLParser.OUT_P - 427)) | (1 << (PostgreSQLParser.ROUTINES - 427)) | (1 << (PostgreSQLParser.SCHEMAS - 427)) | (1 << (PostgreSQLParser.PROCEDURES - 427)) | (1 << (PostgreSQLParser.INPUT_P - 427)) | (1 << (PostgreSQLParser.SUPPORT - 427)) | (1 << (PostgreSQLParser.PARALLEL - 427)) | (1 << (PostgreSQLParser.SQL_P - 427)) | (1 << (PostgreSQLParser.DEPENDS - 427)) | (1 << (PostgreSQLParser.OVERRIDING - 427)) | (1 << (PostgreSQLParser.CONFLICT - 427)) | (1 << (PostgreSQLParser.SKIP_P - 427)) | (1 << (PostgreSQLParser.LOCKED - 427)) | (1 << (PostgreSQLParser.TIES - 427)))) !== 0) || ((((_la - 459)) & ~0x1f) == 0 && ((1 << (_la - 459)) & ((1 << (PostgreSQLParser.ROLLUP - 459)) | (1 << (PostgreSQLParser.CUBE - 459)) | (1 << (PostgreSQLParser.GROUPING - 459)) | (1 << (PostgreSQLParser.SETS - 459)) | (1 << (PostgreSQLParser.TABLESAMPLE - 459)) | (1 << (PostgreSQLParser.ORDINALITY - 459)) | (1 << (PostgreSQLParser.XMLTABLE - 459)) | (1 << (PostgreSQLParser.COLUMNS - 459)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 459)) | (1 << (PostgreSQLParser.ROWTYPE - 459)) | (1 << (PostgreSQLParser.NORMALIZED - 459)) | (1 << (PostgreSQLParser.WITHIN - 459)) | (1 << (PostgreSQLParser.FILTER - 459)) | (1 << (PostgreSQLParser.GROUPS - 459)) | (1 << (PostgreSQLParser.OTHERS - 459)) | (1 << (PostgreSQLParser.NFC - 459)) | (1 << (PostgreSQLParser.NFD - 459)) | (1 << (PostgreSQLParser.NFKC - 459)) | (1 << (PostgreSQLParser.NFKD - 459)) | (1 << (PostgreSQLParser.UESCAPE - 459)) | (1 << (PostgreSQLParser.VIEWS - 459)) | (1 << (PostgreSQLParser.NORMALIZE - 459)) | (1 << (PostgreSQLParser.DUMP - 459)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 459)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 459)) | (1 << (PostgreSQLParser.ERROR - 459)) | (1 << (PostgreSQLParser.USE_VARIABLE - 459)) | (1 << (PostgreSQLParser.USE_COLUMN - 459)) | (1 << (PostgreSQLParser.ALIAS - 459)) | (1 << (PostgreSQLParser.CONSTANT - 459)) | (1 << (PostgreSQLParser.PERFORM - 459)) | (1 << (PostgreSQLParser.GET - 459)))) !== 0) || ((((_la - 491)) & ~0x1f) == 0 && ((1 << (_la - 491)) & ((1 << (PostgreSQLParser.DIAGNOSTICS - 491)) | (1 << (PostgreSQLParser.STACKED - 491)) | (1 << (PostgreSQLParser.ELSIF - 491)) | (1 << (PostgreSQLParser.REVERSE - 491)) | (1 << (PostgreSQLParser.SLICE - 491)) | (1 << (PostgreSQLParser.EXIT - 491)) | (1 << (PostgreSQLParser.RETURN - 491)) | (1 << (PostgreSQLParser.QUERY - 491)) | (1 << (PostgreSQLParser.RAISE - 491)) | (1 << (PostgreSQLParser.SQLSTATE - 491)) | (1 << (PostgreSQLParser.DEBUG - 491)) | (1 << (PostgreSQLParser.LOG - 491)) | (1 << (PostgreSQLParser.INFO - 491)) | (1 << (PostgreSQLParser.NOTICE - 491)) | (1 << (PostgreSQLParser.WARNING - 491)) | (1 << (PostgreSQLParser.EXCEPTION - 491)) | (1 << (PostgreSQLParser.ASSERT - 491)) | (1 << (PostgreSQLParser.OPEN - 491)) | (1 << (PostgreSQLParser.Identifier - 491)) | (1 << (PostgreSQLParser.QuotedIdentifier - 491)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 491)) | (1 << (PostgreSQLParser.StringConstant - 491)))) !== 0) || ((((_la - 523)) & ~0x1f) == 0 && ((1 << (_la - 523)) & ((1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 523)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 523)) | (1 << (PostgreSQLParser.BinaryStringConstant - 523)) | (1 << (PostgreSQLParser.HexadecimalStringConstant - 523)) | (1 << (PostgreSQLParser.Integral - 523)) | (1 << (PostgreSQLParser.Numeric - 523)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 523)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 523)) | (1 << (PostgreSQLParser.EscapeStringConstant - 523)))) !== 0)) { + this.state = 9332; + this.expr_list(); + } + + this.state = 9335; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + case PostgreSQLParser.OPEN_PAREN: + this.enterOuterAlt(localctx, 2); + this.state = 9336; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9337; + this.expr_list(); + this.state = 9338; + this.match(PostgreSQLParser.COMMA); + this.state = 9339; + this.a_expr(); + this.state = 9340; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Explicit_rowContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_explicit_row; + return this; +} + +Explicit_rowContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Explicit_rowContext.prototype.constructor = Explicit_rowContext; + +Explicit_rowContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +Explicit_rowContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Explicit_rowContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Explicit_rowContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Explicit_rowContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExplicit_row(this); + } +}; + +Explicit_rowContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExplicit_row(this); + } +}; + +Explicit_rowContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExplicit_row(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Explicit_rowContext = Explicit_rowContext; + +PostgreSQLParser.prototype.explicit_row = function() { + + var localctx = new Explicit_rowContext(this, this._ctx, this.state); + this.enterRule(localctx, 1252, PostgreSQLParser.RULE_explicit_row); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9344; + this.match(PostgreSQLParser.ROW); + this.state = 9345; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9347; + this._errHandler.sync(this); + _la = this._input.LA(1); + if((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << PostgreSQLParser.OPEN_PAREN) | (1 << PostgreSQLParser.PLUS) | (1 << PostgreSQLParser.MINUS) | (1 << PostgreSQLParser.PARAM) | (1 << PostgreSQLParser.Operator))) !== 0) || ((((_la - 33)) & ~0x1f) == 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.AND - 33)) | (1 << (PostgreSQLParser.ARRAY - 33)) | (1 << (PostgreSQLParser.CASE - 33)) | (1 << (PostgreSQLParser.CAST - 33)) | (1 << (PostgreSQLParser.COLLATE - 33)) | (1 << (PostgreSQLParser.COLUMN - 33)) | (1 << (PostgreSQLParser.CONSTRAINT - 33)) | (1 << (PostgreSQLParser.CURRENT_CATALOG - 33)) | (1 << (PostgreSQLParser.CURRENT_DATE - 33)) | (1 << (PostgreSQLParser.CURRENT_ROLE - 33)) | (1 << (PostgreSQLParser.CURRENT_TIME - 33)) | (1 << (PostgreSQLParser.CURRENT_TIMESTAMP - 33)) | (1 << (PostgreSQLParser.CURRENT_USER - 33)) | (1 << (PostgreSQLParser.DEFAULT - 33)) | (1 << (PostgreSQLParser.DO - 33)) | (1 << (PostgreSQLParser.FALSE_P - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || ((((_la - 75)) & ~0x1f) == 0 && ((1 << (_la - 75)) & ((1 << (PostgreSQLParser.LOCALTIME - 75)) | (1 << (PostgreSQLParser.LOCALTIMESTAMP - 75)) | (1 << (PostgreSQLParser.NOT - 75)) | (1 << (PostgreSQLParser.NULL_P - 75)) | (1 << (PostgreSQLParser.SESSION_USER - 75)) | (1 << (PostgreSQLParser.TABLE - 75)) | (1 << (PostgreSQLParser.TRUE_P - 75)) | (1 << (PostgreSQLParser.UNIQUE - 75)) | (1 << (PostgreSQLParser.USER - 75)) | (1 << (PostgreSQLParser.AUTHORIZATION - 75)))) !== 0) || ((((_la - 107)) & ~0x1f) == 0 && ((1 << (_la - 107)) & ((1 << (PostgreSQLParser.BINARY - 107)) | (1 << (PostgreSQLParser.COLLATION - 107)) | (1 << (PostgreSQLParser.CONCURRENTLY - 107)) | (1 << (PostgreSQLParser.CROSS - 107)) | (1 << (PostgreSQLParser.CURRENT_SCHEMA - 107)) | (1 << (PostgreSQLParser.FREEZE - 107)) | (1 << (PostgreSQLParser.FULL - 107)) | (1 << (PostgreSQLParser.ILIKE - 107)) | (1 << (PostgreSQLParser.INNER_P - 107)) | (1 << (PostgreSQLParser.IS - 107)) | (1 << (PostgreSQLParser.ISNULL - 107)) | (1 << (PostgreSQLParser.JOIN - 107)) | (1 << (PostgreSQLParser.LEFT - 107)) | (1 << (PostgreSQLParser.LIKE - 107)) | (1 << (PostgreSQLParser.NATURAL - 107)) | (1 << (PostgreSQLParser.NOTNULL - 107)) | (1 << (PostgreSQLParser.OUTER_P - 107)) | (1 << (PostgreSQLParser.OVER - 107)) | (1 << (PostgreSQLParser.OVERLAPS - 107)) | (1 << (PostgreSQLParser.RIGHT - 107)) | (1 << (PostgreSQLParser.SIMILAR - 107)) | (1 << (PostgreSQLParser.VERBOSE - 107)) | (1 << (PostgreSQLParser.ABORT_P - 107)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 107)) | (1 << (PostgreSQLParser.ACCESS - 107)) | (1 << (PostgreSQLParser.ACTION - 107)) | (1 << (PostgreSQLParser.ADD_P - 107)) | (1 << (PostgreSQLParser.ADMIN - 107)) | (1 << (PostgreSQLParser.AFTER - 107)) | (1 << (PostgreSQLParser.AGGREGATE - 107)) | (1 << (PostgreSQLParser.ALSO - 107)) | (1 << (PostgreSQLParser.ALTER - 107)))) !== 0) || ((((_la - 139)) & ~0x1f) == 0 && ((1 << (_la - 139)) & ((1 << (PostgreSQLParser.ALWAYS - 139)) | (1 << (PostgreSQLParser.ASSERTION - 139)) | (1 << (PostgreSQLParser.ASSIGNMENT - 139)) | (1 << (PostgreSQLParser.AT - 139)) | (1 << (PostgreSQLParser.ATTRIBUTE - 139)) | (1 << (PostgreSQLParser.BACKWARD - 139)) | (1 << (PostgreSQLParser.BEFORE - 139)) | (1 << (PostgreSQLParser.BEGIN_P - 139)) | (1 << (PostgreSQLParser.BY - 139)) | (1 << (PostgreSQLParser.CACHE - 139)) | (1 << (PostgreSQLParser.CALLED - 139)) | (1 << (PostgreSQLParser.CASCADE - 139)) | (1 << (PostgreSQLParser.CASCADED - 139)) | (1 << (PostgreSQLParser.CATALOG - 139)) | (1 << (PostgreSQLParser.CHAIN - 139)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 139)) | (1 << (PostgreSQLParser.CHECKPOINT - 139)) | (1 << (PostgreSQLParser.CLASS - 139)) | (1 << (PostgreSQLParser.CLOSE - 139)) | (1 << (PostgreSQLParser.CLUSTER - 139)) | (1 << (PostgreSQLParser.COMMENT - 139)) | (1 << (PostgreSQLParser.COMMENTS - 139)) | (1 << (PostgreSQLParser.COMMIT - 139)) | (1 << (PostgreSQLParser.COMMITTED - 139)) | (1 << (PostgreSQLParser.CONFIGURATION - 139)) | (1 << (PostgreSQLParser.CONNECTION - 139)) | (1 << (PostgreSQLParser.CONSTRAINTS - 139)) | (1 << (PostgreSQLParser.CONTENT_P - 139)) | (1 << (PostgreSQLParser.CONTINUE_P - 139)) | (1 << (PostgreSQLParser.CONVERSION_P - 139)) | (1 << (PostgreSQLParser.COPY - 139)) | (1 << (PostgreSQLParser.COST - 139)))) !== 0) || ((((_la - 171)) & ~0x1f) == 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.CSV - 171)) | (1 << (PostgreSQLParser.CURSOR - 171)) | (1 << (PostgreSQLParser.CYCLE - 171)) | (1 << (PostgreSQLParser.DATA_P - 171)) | (1 << (PostgreSQLParser.DATABASE - 171)) | (1 << (PostgreSQLParser.DAY_P - 171)) | (1 << (PostgreSQLParser.DEALLOCATE - 171)) | (1 << (PostgreSQLParser.DECLARE - 171)) | (1 << (PostgreSQLParser.DEFAULTS - 171)) | (1 << (PostgreSQLParser.DEFERRED - 171)) | (1 << (PostgreSQLParser.DEFINER - 171)) | (1 << (PostgreSQLParser.DELETE_P - 171)) | (1 << (PostgreSQLParser.DELIMITER - 171)) | (1 << (PostgreSQLParser.DELIMITERS - 171)) | (1 << (PostgreSQLParser.DICTIONARY - 171)) | (1 << (PostgreSQLParser.DISABLE_P - 171)) | (1 << (PostgreSQLParser.DISCARD - 171)) | (1 << (PostgreSQLParser.DOCUMENT_P - 171)) | (1 << (PostgreSQLParser.DOMAIN_P - 171)) | (1 << (PostgreSQLParser.DOUBLE_P - 171)) | (1 << (PostgreSQLParser.DROP - 171)) | (1 << (PostgreSQLParser.EACH - 171)) | (1 << (PostgreSQLParser.ENABLE_P - 171)) | (1 << (PostgreSQLParser.ENCODING - 171)) | (1 << (PostgreSQLParser.ENCRYPTED - 171)) | (1 << (PostgreSQLParser.ENUM_P - 171)) | (1 << (PostgreSQLParser.ESCAPE - 171)) | (1 << (PostgreSQLParser.EVENT - 171)) | (1 << (PostgreSQLParser.EXCLUDE - 171)) | (1 << (PostgreSQLParser.EXCLUDING - 171)) | (1 << (PostgreSQLParser.EXCLUSIVE - 171)) | (1 << (PostgreSQLParser.EXECUTE - 171)))) !== 0) || ((((_la - 203)) & ~0x1f) == 0 && ((1 << (_la - 203)) & ((1 << (PostgreSQLParser.EXPLAIN - 203)) | (1 << (PostgreSQLParser.EXTENSION - 203)) | (1 << (PostgreSQLParser.EXTERNAL - 203)) | (1 << (PostgreSQLParser.FAMILY - 203)) | (1 << (PostgreSQLParser.FIRST_P - 203)) | (1 << (PostgreSQLParser.FOLLOWING - 203)) | (1 << (PostgreSQLParser.FORCE - 203)) | (1 << (PostgreSQLParser.FORWARD - 203)) | (1 << (PostgreSQLParser.FUNCTION - 203)) | (1 << (PostgreSQLParser.FUNCTIONS - 203)) | (1 << (PostgreSQLParser.GLOBAL - 203)) | (1 << (PostgreSQLParser.GRANTED - 203)) | (1 << (PostgreSQLParser.HANDLER - 203)) | (1 << (PostgreSQLParser.HEADER_P - 203)) | (1 << (PostgreSQLParser.HOLD - 203)) | (1 << (PostgreSQLParser.HOUR_P - 203)) | (1 << (PostgreSQLParser.IDENTITY_P - 203)) | (1 << (PostgreSQLParser.IF_P - 203)) | (1 << (PostgreSQLParser.IMMEDIATE - 203)) | (1 << (PostgreSQLParser.IMMUTABLE - 203)) | (1 << (PostgreSQLParser.IMPLICIT_P - 203)) | (1 << (PostgreSQLParser.INCLUDING - 203)) | (1 << (PostgreSQLParser.INCREMENT - 203)) | (1 << (PostgreSQLParser.INDEX - 203)) | (1 << (PostgreSQLParser.INDEXES - 203)) | (1 << (PostgreSQLParser.INHERIT - 203)) | (1 << (PostgreSQLParser.INHERITS - 203)) | (1 << (PostgreSQLParser.INLINE_P - 203)) | (1 << (PostgreSQLParser.INSENSITIVE - 203)) | (1 << (PostgreSQLParser.INSERT - 203)) | (1 << (PostgreSQLParser.INSTEAD - 203)) | (1 << (PostgreSQLParser.INVOKER - 203)))) !== 0) || ((((_la - 235)) & ~0x1f) == 0 && ((1 << (_la - 235)) & ((1 << (PostgreSQLParser.ISOLATION - 235)) | (1 << (PostgreSQLParser.KEY - 235)) | (1 << (PostgreSQLParser.LABEL - 235)) | (1 << (PostgreSQLParser.LANGUAGE - 235)) | (1 << (PostgreSQLParser.LARGE_P - 235)) | (1 << (PostgreSQLParser.LAST_P - 235)) | (1 << (PostgreSQLParser.LEAKPROOF - 235)) | (1 << (PostgreSQLParser.LEVEL - 235)) | (1 << (PostgreSQLParser.LISTEN - 235)) | (1 << (PostgreSQLParser.LOAD - 235)) | (1 << (PostgreSQLParser.LOCAL - 235)) | (1 << (PostgreSQLParser.LOCATION - 235)) | (1 << (PostgreSQLParser.LOCK_P - 235)) | (1 << (PostgreSQLParser.MAPPING - 235)) | (1 << (PostgreSQLParser.MATCH - 235)) | (1 << (PostgreSQLParser.MATERIALIZED - 235)) | (1 << (PostgreSQLParser.MAXVALUE - 235)) | (1 << (PostgreSQLParser.MINUTE_P - 235)) | (1 << (PostgreSQLParser.MINVALUE - 235)) | (1 << (PostgreSQLParser.MODE - 235)) | (1 << (PostgreSQLParser.MONTH_P - 235)) | (1 << (PostgreSQLParser.MOVE - 235)) | (1 << (PostgreSQLParser.NAME_P - 235)) | (1 << (PostgreSQLParser.NAMES - 235)) | (1 << (PostgreSQLParser.NEXT - 235)) | (1 << (PostgreSQLParser.NO - 235)) | (1 << (PostgreSQLParser.NOTHING - 235)) | (1 << (PostgreSQLParser.NOTIFY - 235)) | (1 << (PostgreSQLParser.NOWAIT - 235)) | (1 << (PostgreSQLParser.NULLS_P - 235)) | (1 << (PostgreSQLParser.OBJECT_P - 235)) | (1 << (PostgreSQLParser.OF - 235)))) !== 0) || ((((_la - 267)) & ~0x1f) == 0 && ((1 << (_la - 267)) & ((1 << (PostgreSQLParser.OFF - 267)) | (1 << (PostgreSQLParser.OIDS - 267)) | (1 << (PostgreSQLParser.OPERATOR - 267)) | (1 << (PostgreSQLParser.OPTION - 267)) | (1 << (PostgreSQLParser.OPTIONS - 267)) | (1 << (PostgreSQLParser.OWNED - 267)) | (1 << (PostgreSQLParser.OWNER - 267)) | (1 << (PostgreSQLParser.PARSER - 267)) | (1 << (PostgreSQLParser.PARTIAL - 267)) | (1 << (PostgreSQLParser.PARTITION - 267)) | (1 << (PostgreSQLParser.PASSING - 267)) | (1 << (PostgreSQLParser.PASSWORD - 267)) | (1 << (PostgreSQLParser.PLANS - 267)) | (1 << (PostgreSQLParser.PRECEDING - 267)) | (1 << (PostgreSQLParser.PREPARE - 267)) | (1 << (PostgreSQLParser.PREPARED - 267)) | (1 << (PostgreSQLParser.PRESERVE - 267)) | (1 << (PostgreSQLParser.PRIOR - 267)) | (1 << (PostgreSQLParser.PRIVILEGES - 267)) | (1 << (PostgreSQLParser.PROCEDURAL - 267)) | (1 << (PostgreSQLParser.PROCEDURE - 267)) | (1 << (PostgreSQLParser.PROGRAM - 267)) | (1 << (PostgreSQLParser.QUOTE - 267)) | (1 << (PostgreSQLParser.RANGE - 267)) | (1 << (PostgreSQLParser.READ - 267)) | (1 << (PostgreSQLParser.REASSIGN - 267)) | (1 << (PostgreSQLParser.RECHECK - 267)) | (1 << (PostgreSQLParser.RECURSIVE - 267)) | (1 << (PostgreSQLParser.REF - 267)) | (1 << (PostgreSQLParser.REFRESH - 267)) | (1 << (PostgreSQLParser.REINDEX - 267)) | (1 << (PostgreSQLParser.RELATIVE_P - 267)))) !== 0) || ((((_la - 299)) & ~0x1f) == 0 && ((1 << (_la - 299)) & ((1 << (PostgreSQLParser.RELEASE - 299)) | (1 << (PostgreSQLParser.RENAME - 299)) | (1 << (PostgreSQLParser.REPEATABLE - 299)) | (1 << (PostgreSQLParser.REPLACE - 299)) | (1 << (PostgreSQLParser.REPLICA - 299)) | (1 << (PostgreSQLParser.RESET - 299)) | (1 << (PostgreSQLParser.RESTART - 299)) | (1 << (PostgreSQLParser.RESTRICT - 299)) | (1 << (PostgreSQLParser.RETURNS - 299)) | (1 << (PostgreSQLParser.REVOKE - 299)) | (1 << (PostgreSQLParser.ROLE - 299)) | (1 << (PostgreSQLParser.ROLLBACK - 299)) | (1 << (PostgreSQLParser.ROWS - 299)) | (1 << (PostgreSQLParser.RULE - 299)) | (1 << (PostgreSQLParser.SAVEPOINT - 299)) | (1 << (PostgreSQLParser.SCHEMA - 299)) | (1 << (PostgreSQLParser.SCROLL - 299)) | (1 << (PostgreSQLParser.SEARCH - 299)) | (1 << (PostgreSQLParser.SECOND_P - 299)) | (1 << (PostgreSQLParser.SECURITY - 299)) | (1 << (PostgreSQLParser.SEQUENCE - 299)) | (1 << (PostgreSQLParser.SEQUENCES - 299)) | (1 << (PostgreSQLParser.SERIALIZABLE - 299)) | (1 << (PostgreSQLParser.SERVER - 299)) | (1 << (PostgreSQLParser.SESSION - 299)) | (1 << (PostgreSQLParser.SET - 299)) | (1 << (PostgreSQLParser.SHARE - 299)) | (1 << (PostgreSQLParser.SHOW - 299)) | (1 << (PostgreSQLParser.SIMPLE - 299)) | (1 << (PostgreSQLParser.SNAPSHOT - 299)) | (1 << (PostgreSQLParser.STABLE - 299)) | (1 << (PostgreSQLParser.STANDALONE_P - 299)))) !== 0) || ((((_la - 331)) & ~0x1f) == 0 && ((1 << (_la - 331)) & ((1 << (PostgreSQLParser.START - 331)) | (1 << (PostgreSQLParser.STATEMENT - 331)) | (1 << (PostgreSQLParser.STATISTICS - 331)) | (1 << (PostgreSQLParser.STDIN - 331)) | (1 << (PostgreSQLParser.STDOUT - 331)) | (1 << (PostgreSQLParser.STORAGE - 331)) | (1 << (PostgreSQLParser.STRICT_P - 331)) | (1 << (PostgreSQLParser.STRIP_P - 331)) | (1 << (PostgreSQLParser.SYSID - 331)) | (1 << (PostgreSQLParser.SYSTEM_P - 331)) | (1 << (PostgreSQLParser.TABLES - 331)) | (1 << (PostgreSQLParser.TABLESPACE - 331)) | (1 << (PostgreSQLParser.TEMP - 331)) | (1 << (PostgreSQLParser.TEMPLATE - 331)) | (1 << (PostgreSQLParser.TEMPORARY - 331)) | (1 << (PostgreSQLParser.TEXT_P - 331)) | (1 << (PostgreSQLParser.TRANSACTION - 331)) | (1 << (PostgreSQLParser.TRIGGER - 331)) | (1 << (PostgreSQLParser.TRUNCATE - 331)) | (1 << (PostgreSQLParser.TRUSTED - 331)) | (1 << (PostgreSQLParser.TYPE_P - 331)) | (1 << (PostgreSQLParser.TYPES_P - 331)) | (1 << (PostgreSQLParser.UNBOUNDED - 331)) | (1 << (PostgreSQLParser.UNCOMMITTED - 331)) | (1 << (PostgreSQLParser.UNENCRYPTED - 331)) | (1 << (PostgreSQLParser.UNKNOWN - 331)) | (1 << (PostgreSQLParser.UNLISTEN - 331)) | (1 << (PostgreSQLParser.UNLOGGED - 331)) | (1 << (PostgreSQLParser.UNTIL - 331)) | (1 << (PostgreSQLParser.UPDATE - 331)) | (1 << (PostgreSQLParser.VACUUM - 331)) | (1 << (PostgreSQLParser.VALID - 331)))) !== 0) || ((((_la - 363)) & ~0x1f) == 0 && ((1 << (_la - 363)) & ((1 << (PostgreSQLParser.VALIDATE - 363)) | (1 << (PostgreSQLParser.VALIDATOR - 363)) | (1 << (PostgreSQLParser.VARYING - 363)) | (1 << (PostgreSQLParser.VERSION_P - 363)) | (1 << (PostgreSQLParser.VIEW - 363)) | (1 << (PostgreSQLParser.VOLATILE - 363)) | (1 << (PostgreSQLParser.WHITESPACE_P - 363)) | (1 << (PostgreSQLParser.WITHOUT - 363)) | (1 << (PostgreSQLParser.WORK - 363)) | (1 << (PostgreSQLParser.WRAPPER - 363)) | (1 << (PostgreSQLParser.WRITE - 363)) | (1 << (PostgreSQLParser.XML_P - 363)) | (1 << (PostgreSQLParser.YEAR_P - 363)) | (1 << (PostgreSQLParser.YES_P - 363)) | (1 << (PostgreSQLParser.ZONE - 363)) | (1 << (PostgreSQLParser.BETWEEN - 363)) | (1 << (PostgreSQLParser.BIGINT - 363)) | (1 << (PostgreSQLParser.BIT - 363)) | (1 << (PostgreSQLParser.BOOLEAN_P - 363)) | (1 << (PostgreSQLParser.CHAR_P - 363)) | (1 << (PostgreSQLParser.CHARACTER - 363)) | (1 << (PostgreSQLParser.COALESCE - 363)) | (1 << (PostgreSQLParser.DEC - 363)) | (1 << (PostgreSQLParser.DECIMAL_P - 363)) | (1 << (PostgreSQLParser.EXISTS - 363)) | (1 << (PostgreSQLParser.EXTRACT - 363)) | (1 << (PostgreSQLParser.FLOAT_P - 363)) | (1 << (PostgreSQLParser.GREATEST - 363)) | (1 << (PostgreSQLParser.INOUT - 363)) | (1 << (PostgreSQLParser.INT_P - 363)) | (1 << (PostgreSQLParser.INTEGER - 363)) | (1 << (PostgreSQLParser.INTERVAL - 363)))) !== 0) || ((((_la - 395)) & ~0x1f) == 0 && ((1 << (_la - 395)) & ((1 << (PostgreSQLParser.LEAST - 395)) | (1 << (PostgreSQLParser.NATIONAL - 395)) | (1 << (PostgreSQLParser.NCHAR - 395)) | (1 << (PostgreSQLParser.NONE - 395)) | (1 << (PostgreSQLParser.NULLIF - 395)) | (1 << (PostgreSQLParser.NUMERIC - 395)) | (1 << (PostgreSQLParser.OVERLAY - 395)) | (1 << (PostgreSQLParser.POSITION - 395)) | (1 << (PostgreSQLParser.PRECISION - 395)) | (1 << (PostgreSQLParser.REAL - 395)) | (1 << (PostgreSQLParser.ROW - 395)) | (1 << (PostgreSQLParser.SETOF - 395)) | (1 << (PostgreSQLParser.SMALLINT - 395)) | (1 << (PostgreSQLParser.SUBSTRING - 395)) | (1 << (PostgreSQLParser.TIME - 395)) | (1 << (PostgreSQLParser.TIMESTAMP - 395)) | (1 << (PostgreSQLParser.TREAT - 395)) | (1 << (PostgreSQLParser.TRIM - 395)) | (1 << (PostgreSQLParser.VALUES - 395)) | (1 << (PostgreSQLParser.VARCHAR - 395)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 395)) | (1 << (PostgreSQLParser.XMLCONCAT - 395)) | (1 << (PostgreSQLParser.XMLELEMENT - 395)) | (1 << (PostgreSQLParser.XMLEXISTS - 395)) | (1 << (PostgreSQLParser.XMLFOREST - 395)) | (1 << (PostgreSQLParser.XMLPARSE - 395)) | (1 << (PostgreSQLParser.XMLPI - 395)) | (1 << (PostgreSQLParser.XMLROOT - 395)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 395)) | (1 << (PostgreSQLParser.CALL - 395)) | (1 << (PostgreSQLParser.CURRENT_P - 395)) | (1 << (PostgreSQLParser.ATTACH - 395)))) !== 0) || ((((_la - 427)) & ~0x1f) == 0 && ((1 << (_la - 427)) & ((1 << (PostgreSQLParser.DETACH - 427)) | (1 << (PostgreSQLParser.EXPRESSION - 427)) | (1 << (PostgreSQLParser.GENERATED - 427)) | (1 << (PostgreSQLParser.LOGGED - 427)) | (1 << (PostgreSQLParser.STORED - 427)) | (1 << (PostgreSQLParser.INCLUDE - 427)) | (1 << (PostgreSQLParser.ROUTINE - 427)) | (1 << (PostgreSQLParser.TRANSFORM - 427)) | (1 << (PostgreSQLParser.IMPORT_P - 427)) | (1 << (PostgreSQLParser.POLICY - 427)) | (1 << (PostgreSQLParser.METHOD - 427)) | (1 << (PostgreSQLParser.REFERENCING - 427)) | (1 << (PostgreSQLParser.NEW - 427)) | (1 << (PostgreSQLParser.OLD - 427)) | (1 << (PostgreSQLParser.VALUE_P - 427)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 427)) | (1 << (PostgreSQLParser.PUBLICATION - 427)) | (1 << (PostgreSQLParser.OUT_P - 427)) | (1 << (PostgreSQLParser.ROUTINES - 427)) | (1 << (PostgreSQLParser.SCHEMAS - 427)) | (1 << (PostgreSQLParser.PROCEDURES - 427)) | (1 << (PostgreSQLParser.INPUT_P - 427)) | (1 << (PostgreSQLParser.SUPPORT - 427)) | (1 << (PostgreSQLParser.PARALLEL - 427)) | (1 << (PostgreSQLParser.SQL_P - 427)) | (1 << (PostgreSQLParser.DEPENDS - 427)) | (1 << (PostgreSQLParser.OVERRIDING - 427)) | (1 << (PostgreSQLParser.CONFLICT - 427)) | (1 << (PostgreSQLParser.SKIP_P - 427)) | (1 << (PostgreSQLParser.LOCKED - 427)) | (1 << (PostgreSQLParser.TIES - 427)))) !== 0) || ((((_la - 459)) & ~0x1f) == 0 && ((1 << (_la - 459)) & ((1 << (PostgreSQLParser.ROLLUP - 459)) | (1 << (PostgreSQLParser.CUBE - 459)) | (1 << (PostgreSQLParser.GROUPING - 459)) | (1 << (PostgreSQLParser.SETS - 459)) | (1 << (PostgreSQLParser.TABLESAMPLE - 459)) | (1 << (PostgreSQLParser.ORDINALITY - 459)) | (1 << (PostgreSQLParser.XMLTABLE - 459)) | (1 << (PostgreSQLParser.COLUMNS - 459)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 459)) | (1 << (PostgreSQLParser.ROWTYPE - 459)) | (1 << (PostgreSQLParser.NORMALIZED - 459)) | (1 << (PostgreSQLParser.WITHIN - 459)) | (1 << (PostgreSQLParser.FILTER - 459)) | (1 << (PostgreSQLParser.GROUPS - 459)) | (1 << (PostgreSQLParser.OTHERS - 459)) | (1 << (PostgreSQLParser.NFC - 459)) | (1 << (PostgreSQLParser.NFD - 459)) | (1 << (PostgreSQLParser.NFKC - 459)) | (1 << (PostgreSQLParser.NFKD - 459)) | (1 << (PostgreSQLParser.UESCAPE - 459)) | (1 << (PostgreSQLParser.VIEWS - 459)) | (1 << (PostgreSQLParser.NORMALIZE - 459)) | (1 << (PostgreSQLParser.DUMP - 459)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 459)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 459)) | (1 << (PostgreSQLParser.ERROR - 459)) | (1 << (PostgreSQLParser.USE_VARIABLE - 459)) | (1 << (PostgreSQLParser.USE_COLUMN - 459)) | (1 << (PostgreSQLParser.ALIAS - 459)) | (1 << (PostgreSQLParser.CONSTANT - 459)) | (1 << (PostgreSQLParser.PERFORM - 459)) | (1 << (PostgreSQLParser.GET - 459)))) !== 0) || ((((_la - 491)) & ~0x1f) == 0 && ((1 << (_la - 491)) & ((1 << (PostgreSQLParser.DIAGNOSTICS - 491)) | (1 << (PostgreSQLParser.STACKED - 491)) | (1 << (PostgreSQLParser.ELSIF - 491)) | (1 << (PostgreSQLParser.REVERSE - 491)) | (1 << (PostgreSQLParser.SLICE - 491)) | (1 << (PostgreSQLParser.EXIT - 491)) | (1 << (PostgreSQLParser.RETURN - 491)) | (1 << (PostgreSQLParser.QUERY - 491)) | (1 << (PostgreSQLParser.RAISE - 491)) | (1 << (PostgreSQLParser.SQLSTATE - 491)) | (1 << (PostgreSQLParser.DEBUG - 491)) | (1 << (PostgreSQLParser.LOG - 491)) | (1 << (PostgreSQLParser.INFO - 491)) | (1 << (PostgreSQLParser.NOTICE - 491)) | (1 << (PostgreSQLParser.WARNING - 491)) | (1 << (PostgreSQLParser.EXCEPTION - 491)) | (1 << (PostgreSQLParser.ASSERT - 491)) | (1 << (PostgreSQLParser.OPEN - 491)) | (1 << (PostgreSQLParser.Identifier - 491)) | (1 << (PostgreSQLParser.QuotedIdentifier - 491)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 491)) | (1 << (PostgreSQLParser.StringConstant - 491)))) !== 0) || ((((_la - 523)) & ~0x1f) == 0 && ((1 << (_la - 523)) & ((1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 523)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 523)) | (1 << (PostgreSQLParser.BinaryStringConstant - 523)) | (1 << (PostgreSQLParser.HexadecimalStringConstant - 523)) | (1 << (PostgreSQLParser.Integral - 523)) | (1 << (PostgreSQLParser.Numeric - 523)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 523)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 523)) | (1 << (PostgreSQLParser.EscapeStringConstant - 523)))) !== 0)) { + this.state = 9346; + this.expr_list(); + } + + this.state = 9349; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Implicit_rowContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_implicit_row; + return this; +} + +Implicit_rowContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Implicit_rowContext.prototype.constructor = Implicit_rowContext; + +Implicit_rowContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Implicit_rowContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Implicit_rowContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +Implicit_rowContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Implicit_rowContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Implicit_rowContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterImplicit_row(this); + } +}; + +Implicit_rowContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitImplicit_row(this); + } +}; + +Implicit_rowContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitImplicit_row(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Implicit_rowContext = Implicit_rowContext; + +PostgreSQLParser.prototype.implicit_row = function() { + + var localctx = new Implicit_rowContext(this, this._ctx, this.state); + this.enterRule(localctx, 1254, PostgreSQLParser.RULE_implicit_row); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9351; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9352; + this.expr_list(); + this.state = 9353; + this.match(PostgreSQLParser.COMMA); + this.state = 9354; + this.a_expr(); + this.state = 9355; + this.match(PostgreSQLParser.CLOSE_PAREN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Sub_typeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_sub_type; + return this; +} + +Sub_typeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Sub_typeContext.prototype.constructor = Sub_typeContext; + +Sub_typeContext.prototype.ANY = function() { + return this.getToken(PostgreSQLParser.ANY, 0); +}; + +Sub_typeContext.prototype.SOME = function() { + return this.getToken(PostgreSQLParser.SOME, 0); +}; + +Sub_typeContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Sub_typeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSub_type(this); + } +}; + +Sub_typeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSub_type(this); + } +}; + +Sub_typeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSub_type(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Sub_typeContext = Sub_typeContext; + +PostgreSQLParser.prototype.sub_type = function() { + + var localctx = new Sub_typeContext(this, this._ctx, this.state); + this.enterRule(localctx, 1256, PostgreSQLParser.RULE_sub_type); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9357; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.ALL || _la===PostgreSQLParser.ANY || _la===PostgreSQLParser.SOME)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function All_opContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_all_op; + return this; +} + +All_opContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +All_opContext.prototype.constructor = All_opContext; + +All_opContext.prototype.Operator = function() { + return this.getToken(PostgreSQLParser.Operator, 0); +}; + +All_opContext.prototype.mathop = function() { + return this.getTypedRuleContext(MathopContext,0); +}; + +All_opContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAll_op(this); + } +}; + +All_opContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAll_op(this); + } +}; + +All_opContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAll_op(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.All_opContext = All_opContext; + +PostgreSQLParser.prototype.all_op = function() { + + var localctx = new All_opContext(this, this._ctx, this.state); + this.enterRule(localctx, 1258, PostgreSQLParser.RULE_all_op); + try { + this.state = 9361; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.Operator: + this.enterOuterAlt(localctx, 1); + this.state = 9359; + this.match(PostgreSQLParser.Operator); + break; + case PostgreSQLParser.STAR: + case PostgreSQLParser.EQUAL: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.SLASH: + case PostgreSQLParser.CARET: + case PostgreSQLParser.LT: + case PostgreSQLParser.GT: + case PostgreSQLParser.LESS_EQUALS: + case PostgreSQLParser.GREATER_EQUALS: + case PostgreSQLParser.NOT_EQUALS: + case PostgreSQLParser.PERCENT: + this.enterOuterAlt(localctx, 2); + this.state = 9360; + this.mathop(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function MathopContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_mathop; + return this; +} + +MathopContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +MathopContext.prototype.constructor = MathopContext; + +MathopContext.prototype.PLUS = function() { + return this.getToken(PostgreSQLParser.PLUS, 0); +}; + +MathopContext.prototype.MINUS = function() { + return this.getToken(PostgreSQLParser.MINUS, 0); +}; + +MathopContext.prototype.STAR = function() { + return this.getToken(PostgreSQLParser.STAR, 0); +}; + +MathopContext.prototype.SLASH = function() { + return this.getToken(PostgreSQLParser.SLASH, 0); +}; + +MathopContext.prototype.PERCENT = function() { + return this.getToken(PostgreSQLParser.PERCENT, 0); +}; + +MathopContext.prototype.CARET = function() { + return this.getToken(PostgreSQLParser.CARET, 0); +}; + +MathopContext.prototype.LT = function() { + return this.getToken(PostgreSQLParser.LT, 0); +}; + +MathopContext.prototype.GT = function() { + return this.getToken(PostgreSQLParser.GT, 0); +}; + +MathopContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +MathopContext.prototype.LESS_EQUALS = function() { + return this.getToken(PostgreSQLParser.LESS_EQUALS, 0); +}; + +MathopContext.prototype.GREATER_EQUALS = function() { + return this.getToken(PostgreSQLParser.GREATER_EQUALS, 0); +}; + +MathopContext.prototype.NOT_EQUALS = function() { + return this.getToken(PostgreSQLParser.NOT_EQUALS, 0); +}; + +MathopContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterMathop(this); + } +}; + +MathopContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitMathop(this); + } +}; + +MathopContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitMathop(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.MathopContext = MathopContext; + +PostgreSQLParser.prototype.mathop = function() { + + var localctx = new MathopContext(this, this._ctx, this.state); + this.enterRule(localctx, 1260, PostgreSQLParser.RULE_mathop); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9363; + _la = this._input.LA(1); + if(!((((_la) & ~0x1f) == 0 && ((1 << _la) & ((1 << PostgreSQLParser.STAR) | (1 << PostgreSQLParser.EQUAL) | (1 << PostgreSQLParser.PLUS) | (1 << PostgreSQLParser.MINUS) | (1 << PostgreSQLParser.SLASH) | (1 << PostgreSQLParser.CARET) | (1 << PostgreSQLParser.LT) | (1 << PostgreSQLParser.GT) | (1 << PostgreSQLParser.LESS_EQUALS) | (1 << PostgreSQLParser.GREATER_EQUALS) | (1 << PostgreSQLParser.NOT_EQUALS) | (1 << PostgreSQLParser.PERCENT))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Qual_opContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_qual_op; + return this; +} + +Qual_opContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Qual_opContext.prototype.constructor = Qual_opContext; + +Qual_opContext.prototype.Operator = function() { + return this.getToken(PostgreSQLParser.Operator, 0); +}; + +Qual_opContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +Qual_opContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Qual_opContext.prototype.any_operator = function() { + return this.getTypedRuleContext(Any_operatorContext,0); +}; + +Qual_opContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Qual_opContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterQual_op(this); + } +}; + +Qual_opContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitQual_op(this); + } +}; + +Qual_opContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitQual_op(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Qual_opContext = Qual_opContext; + +PostgreSQLParser.prototype.qual_op = function() { + + var localctx = new Qual_opContext(this, this._ctx, this.state); + this.enterRule(localctx, 1262, PostgreSQLParser.RULE_qual_op); + try { + this.state = 9371; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.Operator: + this.enterOuterAlt(localctx, 1); + this.state = 9365; + this.match(PostgreSQLParser.Operator); + break; + case PostgreSQLParser.OPERATOR: + this.enterOuterAlt(localctx, 2); + this.state = 9366; + this.match(PostgreSQLParser.OPERATOR); + this.state = 9367; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9368; + this.any_operator(); + this.state = 9369; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Qual_all_opContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_qual_all_op; + return this; +} + +Qual_all_opContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Qual_all_opContext.prototype.constructor = Qual_all_opContext; + +Qual_all_opContext.prototype.all_op = function() { + return this.getTypedRuleContext(All_opContext,0); +}; + +Qual_all_opContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +Qual_all_opContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Qual_all_opContext.prototype.any_operator = function() { + return this.getTypedRuleContext(Any_operatorContext,0); +}; + +Qual_all_opContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Qual_all_opContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterQual_all_op(this); + } +}; + +Qual_all_opContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitQual_all_op(this); + } +}; + +Qual_all_opContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitQual_all_op(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Qual_all_opContext = Qual_all_opContext; + +PostgreSQLParser.prototype.qual_all_op = function() { + + var localctx = new Qual_all_opContext(this, this._ctx, this.state); + this.enterRule(localctx, 1264, PostgreSQLParser.RULE_qual_all_op); + try { + this.state = 9379; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.STAR: + case PostgreSQLParser.EQUAL: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.SLASH: + case PostgreSQLParser.CARET: + case PostgreSQLParser.LT: + case PostgreSQLParser.GT: + case PostgreSQLParser.LESS_EQUALS: + case PostgreSQLParser.GREATER_EQUALS: + case PostgreSQLParser.NOT_EQUALS: + case PostgreSQLParser.PERCENT: + case PostgreSQLParser.Operator: + this.enterOuterAlt(localctx, 1); + this.state = 9373; + this.all_op(); + break; + case PostgreSQLParser.OPERATOR: + this.enterOuterAlt(localctx, 2); + this.state = 9374; + this.match(PostgreSQLParser.OPERATOR); + this.state = 9375; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9376; + this.any_operator(); + this.state = 9377; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Subquery_OpContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_subquery_Op; + return this; +} + +Subquery_OpContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Subquery_OpContext.prototype.constructor = Subquery_OpContext; + +Subquery_OpContext.prototype.all_op = function() { + return this.getTypedRuleContext(All_opContext,0); +}; + +Subquery_OpContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +Subquery_OpContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Subquery_OpContext.prototype.any_operator = function() { + return this.getTypedRuleContext(Any_operatorContext,0); +}; + +Subquery_OpContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Subquery_OpContext.prototype.LIKE = function() { + return this.getToken(PostgreSQLParser.LIKE, 0); +}; + +Subquery_OpContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +Subquery_OpContext.prototype.ILIKE = function() { + return this.getToken(PostgreSQLParser.ILIKE, 0); +}; + +Subquery_OpContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSubquery_Op(this); + } +}; + +Subquery_OpContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSubquery_Op(this); + } +}; + +Subquery_OpContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSubquery_Op(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Subquery_OpContext = Subquery_OpContext; + +PostgreSQLParser.prototype.subquery_Op = function() { + + var localctx = new Subquery_OpContext(this, this._ctx, this.state); + this.enterRule(localctx, 1266, PostgreSQLParser.RULE_subquery_Op); + try { + this.state = 9393; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,596,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9381; + this.all_op(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9382; + this.match(PostgreSQLParser.OPERATOR); + this.state = 9383; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9384; + this.any_operator(); + this.state = 9385; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9387; + this.match(PostgreSQLParser.LIKE); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9388; + this.match(PostgreSQLParser.NOT); + this.state = 9389; + this.match(PostgreSQLParser.LIKE); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 9390; + this.match(PostgreSQLParser.ILIKE); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 9391; + this.match(PostgreSQLParser.NOT); + this.state = 9392; + this.match(PostgreSQLParser.ILIKE); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Expr_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_expr_list; + return this; +} + +Expr_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Expr_listContext.prototype.constructor = Expr_listContext; + +Expr_listContext.prototype.a_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_exprContext); + } else { + return this.getTypedRuleContext(A_exprContext,i); + } +}; + +Expr_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Expr_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExpr_list(this); + } +}; + +Expr_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExpr_list(this); + } +}; + +Expr_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExpr_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Expr_listContext = Expr_listContext; + +PostgreSQLParser.prototype.expr_list = function() { + + var localctx = new Expr_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1268, PostgreSQLParser.RULE_expr_list); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9395; + this.a_expr(); + this.state = 9400; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,597,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 9396; + this.match(PostgreSQLParser.COMMA); + this.state = 9397; + this.a_expr(); + } + this.state = 9402; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,597,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_arg_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_arg_list; + return this; +} + +Func_arg_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_arg_listContext.prototype.constructor = Func_arg_listContext; + +Func_arg_listContext.prototype.func_arg_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Func_arg_exprContext); + } else { + return this.getTypedRuleContext(Func_arg_exprContext,i); + } +}; + +Func_arg_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Func_arg_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_arg_list(this); + } +}; + +Func_arg_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_arg_list(this); + } +}; + +Func_arg_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_arg_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_arg_listContext = Func_arg_listContext; + +PostgreSQLParser.prototype.func_arg_list = function() { + + var localctx = new Func_arg_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1270, PostgreSQLParser.RULE_func_arg_list); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9403; + this.func_arg_expr(); + this.state = 9408; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,598,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 9404; + this.match(PostgreSQLParser.COMMA); + this.state = 9405; + this.func_arg_expr(); + } + this.state = 9410; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,598,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_arg_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_arg_expr; + return this; +} + +Func_arg_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_arg_exprContext.prototype.constructor = Func_arg_exprContext; + +Func_arg_exprContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Func_arg_exprContext.prototype.param_name = function() { + return this.getTypedRuleContext(Param_nameContext,0); +}; + +Func_arg_exprContext.prototype.COLON_EQUALS = function() { + return this.getToken(PostgreSQLParser.COLON_EQUALS, 0); +}; + +Func_arg_exprContext.prototype.EQUALS_GREATER = function() { + return this.getToken(PostgreSQLParser.EQUALS_GREATER, 0); +}; + +Func_arg_exprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_arg_expr(this); + } +}; + +Func_arg_exprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_arg_expr(this); + } +}; + +Func_arg_exprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_arg_expr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_arg_exprContext = Func_arg_exprContext; + +PostgreSQLParser.prototype.func_arg_expr = function() { + + var localctx = new Func_arg_exprContext(this, this._ctx, this.state); + this.enterRule(localctx, 1272, PostgreSQLParser.RULE_func_arg_expr); + var _la = 0; // Token type + try { + this.state = 9416; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,599,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9411; + this.a_expr(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9412; + this.param_name(); + this.state = 9413; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.COLON_EQUALS || _la===PostgreSQLParser.EQUALS_GREATER)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 9414; + this.a_expr(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Type_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_type_list; + return this; +} + +Type_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Type_listContext.prototype.constructor = Type_listContext; + +Type_listContext.prototype.typename = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(TypenameContext); + } else { + return this.getTypedRuleContext(TypenameContext,i); + } +}; + +Type_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Type_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterType_list(this); + } +}; + +Type_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitType_list(this); + } +}; + +Type_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitType_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Type_listContext = Type_listContext; + +PostgreSQLParser.prototype.type_list = function() { + + var localctx = new Type_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1274, PostgreSQLParser.RULE_type_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9418; + this.typename(); + this.state = 9423; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 9419; + this.match(PostgreSQLParser.COMMA); + this.state = 9420; + this.typename(); + this.state = 9425; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Array_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_array_expr; + return this; +} + +Array_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Array_exprContext.prototype.constructor = Array_exprContext; + +Array_exprContext.prototype.OPEN_BRACKET = function() { + return this.getToken(PostgreSQLParser.OPEN_BRACKET, 0); +}; + +Array_exprContext.prototype.CLOSE_BRACKET = function() { + return this.getToken(PostgreSQLParser.CLOSE_BRACKET, 0); +}; + +Array_exprContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Array_exprContext.prototype.array_expr_list = function() { + return this.getTypedRuleContext(Array_expr_listContext,0); +}; + +Array_exprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterArray_expr(this); + } +}; + +Array_exprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitArray_expr(this); + } +}; + +Array_exprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitArray_expr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Array_exprContext = Array_exprContext; + +PostgreSQLParser.prototype.array_expr = function() { + + var localctx = new Array_exprContext(this, this._ctx, this.state); + this.enterRule(localctx, 1276, PostgreSQLParser.RULE_array_expr); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9426; + this.match(PostgreSQLParser.OPEN_BRACKET); + this.state = 9429; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.Operator: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.state = 9427; + this.expr_list(); + break; + case PostgreSQLParser.OPEN_BRACKET: + this.state = 9428; + this.array_expr_list(); + break; + case PostgreSQLParser.CLOSE_BRACKET: + break; + default: + break; + } + this.state = 9431; + this.match(PostgreSQLParser.CLOSE_BRACKET); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Array_expr_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_array_expr_list; + return this; +} + +Array_expr_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Array_expr_listContext.prototype.constructor = Array_expr_listContext; + +Array_expr_listContext.prototype.array_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Array_exprContext); + } else { + return this.getTypedRuleContext(Array_exprContext,i); + } +}; + +Array_expr_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Array_expr_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterArray_expr_list(this); + } +}; + +Array_expr_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitArray_expr_list(this); + } +}; + +Array_expr_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitArray_expr_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Array_expr_listContext = Array_expr_listContext; + +PostgreSQLParser.prototype.array_expr_list = function() { + + var localctx = new Array_expr_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1278, PostgreSQLParser.RULE_array_expr_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9433; + this.array_expr(); + this.state = 9438; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 9434; + this.match(PostgreSQLParser.COMMA); + this.state = 9435; + this.array_expr(); + this.state = 9440; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Extract_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_extract_list; + return this; +} + +Extract_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Extract_listContext.prototype.constructor = Extract_listContext; + +Extract_listContext.prototype.extract_arg = function() { + return this.getTypedRuleContext(Extract_argContext,0); +}; + +Extract_listContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Extract_listContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Extract_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExtract_list(this); + } +}; + +Extract_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExtract_list(this); + } +}; + +Extract_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExtract_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Extract_listContext = Extract_listContext; + +PostgreSQLParser.prototype.extract_list = function() { + + var localctx = new Extract_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1280, PostgreSQLParser.RULE_extract_list); + try { + this.state = 9446; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RESET: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SET: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 9441; + this.extract_arg(); + this.state = 9442; + this.match(PostgreSQLParser.FROM); + this.state = 9443; + this.a_expr(); + break; + case PostgreSQLParser.CLOSE_PAREN: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Extract_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_extract_arg; + return this; +} + +Extract_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Extract_argContext.prototype.constructor = Extract_argContext; + +Extract_argContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +Extract_argContext.prototype.YEAR_P = function() { + return this.getToken(PostgreSQLParser.YEAR_P, 0); +}; + +Extract_argContext.prototype.MONTH_P = function() { + return this.getToken(PostgreSQLParser.MONTH_P, 0); +}; + +Extract_argContext.prototype.DAY_P = function() { + return this.getToken(PostgreSQLParser.DAY_P, 0); +}; + +Extract_argContext.prototype.HOUR_P = function() { + return this.getToken(PostgreSQLParser.HOUR_P, 0); +}; + +Extract_argContext.prototype.MINUTE_P = function() { + return this.getToken(PostgreSQLParser.MINUTE_P, 0); +}; + +Extract_argContext.prototype.SECOND_P = function() { + return this.getToken(PostgreSQLParser.SECOND_P, 0); +}; + +Extract_argContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Extract_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExtract_arg(this); + } +}; + +Extract_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExtract_arg(this); + } +}; + +Extract_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExtract_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Extract_argContext = Extract_argContext; + +PostgreSQLParser.prototype.extract_arg = function() { + + var localctx = new Extract_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 1282, PostgreSQLParser.RULE_extract_arg); + try { + this.state = 9456; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RESET: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SET: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 9448; + this.identifier(); + break; + case PostgreSQLParser.YEAR_P: + this.enterOuterAlt(localctx, 2); + this.state = 9449; + this.match(PostgreSQLParser.YEAR_P); + break; + case PostgreSQLParser.MONTH_P: + this.enterOuterAlt(localctx, 3); + this.state = 9450; + this.match(PostgreSQLParser.MONTH_P); + break; + case PostgreSQLParser.DAY_P: + this.enterOuterAlt(localctx, 4); + this.state = 9451; + this.match(PostgreSQLParser.DAY_P); + break; + case PostgreSQLParser.HOUR_P: + this.enterOuterAlt(localctx, 5); + this.state = 9452; + this.match(PostgreSQLParser.HOUR_P); + break; + case PostgreSQLParser.MINUTE_P: + this.enterOuterAlt(localctx, 6); + this.state = 9453; + this.match(PostgreSQLParser.MINUTE_P); + break; + case PostgreSQLParser.SECOND_P: + this.enterOuterAlt(localctx, 7); + this.state = 9454; + this.match(PostgreSQLParser.SECOND_P); + break; + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 8); + this.state = 9455; + this.sconst(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Unicode_normal_formContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_unicode_normal_form; + return this; +} + +Unicode_normal_formContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Unicode_normal_formContext.prototype.constructor = Unicode_normal_formContext; + +Unicode_normal_formContext.prototype.NFC = function() { + return this.getToken(PostgreSQLParser.NFC, 0); +}; + +Unicode_normal_formContext.prototype.NFD = function() { + return this.getToken(PostgreSQLParser.NFD, 0); +}; + +Unicode_normal_formContext.prototype.NFKC = function() { + return this.getToken(PostgreSQLParser.NFKC, 0); +}; + +Unicode_normal_formContext.prototype.NFKD = function() { + return this.getToken(PostgreSQLParser.NFKD, 0); +}; + +Unicode_normal_formContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterUnicode_normal_form(this); + } +}; + +Unicode_normal_formContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitUnicode_normal_form(this); + } +}; + +Unicode_normal_formContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitUnicode_normal_form(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Unicode_normal_formContext = Unicode_normal_formContext; + +PostgreSQLParser.prototype.unicode_normal_form = function() { + + var localctx = new Unicode_normal_formContext(this, this._ctx, this.state); + this.enterRule(localctx, 1284, PostgreSQLParser.RULE_unicode_normal_form); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9458; + _la = this._input.LA(1); + if(!(((((_la - 474)) & ~0x1f) == 0 && ((1 << (_la - 474)) & ((1 << (PostgreSQLParser.NFC - 474)) | (1 << (PostgreSQLParser.NFD - 474)) | (1 << (PostgreSQLParser.NFKC - 474)) | (1 << (PostgreSQLParser.NFKD - 474)))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Overlay_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_overlay_list; + return this; +} + +Overlay_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Overlay_listContext.prototype.constructor = Overlay_listContext; + +Overlay_listContext.prototype.a_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_exprContext); + } else { + return this.getTypedRuleContext(A_exprContext,i); + } +}; + +Overlay_listContext.prototype.PLACING = function() { + return this.getToken(PostgreSQLParser.PLACING, 0); +}; + +Overlay_listContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Overlay_listContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Overlay_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOverlay_list(this); + } +}; + +Overlay_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOverlay_list(this); + } +}; + +Overlay_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOverlay_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Overlay_listContext = Overlay_listContext; + +PostgreSQLParser.prototype.overlay_list = function() { + + var localctx = new Overlay_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1286, PostgreSQLParser.RULE_overlay_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9460; + this.a_expr(); + this.state = 9461; + this.match(PostgreSQLParser.PLACING); + this.state = 9462; + this.a_expr(); + this.state = 9463; + this.match(PostgreSQLParser.FROM); + this.state = 9464; + this.a_expr(); + this.state = 9467; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.FOR) { + this.state = 9465; + this.match(PostgreSQLParser.FOR); + this.state = 9466; + this.a_expr(); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Position_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_position_list; + return this; +} + +Position_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Position_listContext.prototype.constructor = Position_listContext; + +Position_listContext.prototype.b_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(B_exprContext); + } else { + return this.getTypedRuleContext(B_exprContext,i); + } +}; + +Position_listContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +Position_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPosition_list(this); + } +}; + +Position_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPosition_list(this); + } +}; + +Position_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPosition_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Position_listContext = Position_listContext; + +PostgreSQLParser.prototype.position_list = function() { + + var localctx = new Position_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1288, PostgreSQLParser.RULE_position_list); + try { + this.state = 9474; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.Operator: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 9469; + this.b_expr(0); + this.state = 9470; + this.match(PostgreSQLParser.IN_P); + this.state = 9471; + this.b_expr(0); + break; + case PostgreSQLParser.CLOSE_PAREN: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Substr_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_substr_list; + return this; +} + +Substr_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Substr_listContext.prototype.constructor = Substr_listContext; + +Substr_listContext.prototype.a_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_exprContext); + } else { + return this.getTypedRuleContext(A_exprContext,i); + } +}; + +Substr_listContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Substr_listContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Substr_listContext.prototype.SIMILAR = function() { + return this.getToken(PostgreSQLParser.SIMILAR, 0); +}; + +Substr_listContext.prototype.ESCAPE = function() { + return this.getToken(PostgreSQLParser.ESCAPE, 0); +}; + +Substr_listContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Substr_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSubstr_list(this); + } +}; + +Substr_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSubstr_list(this); + } +}; + +Substr_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSubstr_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Substr_listContext = Substr_listContext; + +PostgreSQLParser.prototype.substr_list = function() { + + var localctx = new Substr_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1290, PostgreSQLParser.RULE_substr_list); + try { + this.state = 9504; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,607,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9476; + this.a_expr(); + this.state = 9477; + this.match(PostgreSQLParser.FROM); + this.state = 9478; + this.a_expr(); + this.state = 9479; + this.match(PostgreSQLParser.FOR); + this.state = 9480; + this.a_expr(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9482; + this.a_expr(); + this.state = 9483; + this.match(PostgreSQLParser.FOR); + this.state = 9484; + this.a_expr(); + this.state = 9485; + this.match(PostgreSQLParser.FROM); + this.state = 9486; + this.a_expr(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9488; + this.a_expr(); + this.state = 9489; + this.match(PostgreSQLParser.FROM); + this.state = 9490; + this.a_expr(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9492; + this.a_expr(); + this.state = 9493; + this.match(PostgreSQLParser.FOR); + this.state = 9494; + this.a_expr(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 9496; + this.a_expr(); + this.state = 9497; + this.match(PostgreSQLParser.SIMILAR); + this.state = 9498; + this.a_expr(); + this.state = 9499; + this.match(PostgreSQLParser.ESCAPE); + this.state = 9500; + this.a_expr(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 9502; + this.expr_list(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Trim_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_trim_list; + return this; +} + +Trim_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Trim_listContext.prototype.constructor = Trim_listContext; + +Trim_listContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Trim_listContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Trim_listContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Trim_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTrim_list(this); + } +}; + +Trim_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTrim_list(this); + } +}; + +Trim_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTrim_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Trim_listContext = Trim_listContext; + +PostgreSQLParser.prototype.trim_list = function() { + + var localctx = new Trim_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1292, PostgreSQLParser.RULE_trim_list); + try { + this.state = 9513; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,608,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9506; + this.a_expr(); + this.state = 9507; + this.match(PostgreSQLParser.FROM); + this.state = 9508; + this.expr_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9510; + this.match(PostgreSQLParser.FROM); + this.state = 9511; + this.expr_list(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9512; + this.expr_list(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function In_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_in_expr; + return this; +} + +In_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +In_exprContext.prototype.constructor = In_exprContext; + + + +In_exprContext.prototype.copyFrom = function(ctx) { + antlr4.ParserRuleContext.prototype.copyFrom.call(this, ctx); +}; + + +function In_expr_listContext(parser, ctx) { + In_exprContext.call(this, parser); + In_exprContext.prototype.copyFrom.call(this, ctx); + return this; +} + +In_expr_listContext.prototype = Object.create(In_exprContext.prototype); +In_expr_listContext.prototype.constructor = In_expr_listContext; + +PostgreSQLParser.In_expr_listContext = In_expr_listContext; + +In_expr_listContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +In_expr_listContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +In_expr_listContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; +In_expr_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIn_expr_list(this); + } +}; + +In_expr_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIn_expr_list(this); + } +}; + +In_expr_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIn_expr_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + +function In_expr_selectContext(parser, ctx) { + In_exprContext.call(this, parser); + In_exprContext.prototype.copyFrom.call(this, ctx); + return this; +} + +In_expr_selectContext.prototype = Object.create(In_exprContext.prototype); +In_expr_selectContext.prototype.constructor = In_expr_selectContext; + +PostgreSQLParser.In_expr_selectContext = In_expr_selectContext; + +In_expr_selectContext.prototype.select_with_parens = function() { + return this.getTypedRuleContext(Select_with_parensContext,0); +}; +In_expr_selectContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIn_expr_select(this); + } +}; + +In_expr_selectContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIn_expr_select(this); + } +}; + +In_expr_selectContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIn_expr_select(this); + } else { + return visitor.visitChildren(this); + } +}; + + + +PostgreSQLParser.In_exprContext = In_exprContext; + +PostgreSQLParser.prototype.in_expr = function() { + + var localctx = new In_exprContext(this, this._ctx, this.state); + this.enterRule(localctx, 1294, PostgreSQLParser.RULE_in_expr); + try { + this.state = 9520; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,609,this._ctx); + switch(la_) { + case 1: + localctx = new In_expr_selectContext(this, localctx); + this.enterOuterAlt(localctx, 1); + this.state = 9515; + this.select_with_parens(); + break; + + case 2: + localctx = new In_expr_listContext(this, localctx); + this.enterOuterAlt(localctx, 2); + this.state = 9516; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9517; + this.expr_list(); + this.state = 9518; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Case_exprContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_case_expr; + return this; +} + +Case_exprContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Case_exprContext.prototype.constructor = Case_exprContext; + +Case_exprContext.prototype.CASE = function() { + return this.getToken(PostgreSQLParser.CASE, 0); +}; + +Case_exprContext.prototype.case_arg = function() { + return this.getTypedRuleContext(Case_argContext,0); +}; + +Case_exprContext.prototype.when_clause_list = function() { + return this.getTypedRuleContext(When_clause_listContext,0); +}; + +Case_exprContext.prototype.case_default = function() { + return this.getTypedRuleContext(Case_defaultContext,0); +}; + +Case_exprContext.prototype.END_P = function() { + return this.getToken(PostgreSQLParser.END_P, 0); +}; + +Case_exprContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCase_expr(this); + } +}; + +Case_exprContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCase_expr(this); + } +}; + +Case_exprContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCase_expr(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Case_exprContext = Case_exprContext; + +PostgreSQLParser.prototype.case_expr = function() { + + var localctx = new Case_exprContext(this, this._ctx, this.state); + this.enterRule(localctx, 1296, PostgreSQLParser.RULE_case_expr); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9522; + this.match(PostgreSQLParser.CASE); + this.state = 9523; + this.case_arg(); + this.state = 9524; + this.when_clause_list(); + this.state = 9525; + this.case_default(); + this.state = 9526; + this.match(PostgreSQLParser.END_P); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function When_clause_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_when_clause_list; + return this; +} + +When_clause_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +When_clause_listContext.prototype.constructor = When_clause_listContext; + +When_clause_listContext.prototype.when_clause = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(When_clauseContext); + } else { + return this.getTypedRuleContext(When_clauseContext,i); + } +}; + +When_clause_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterWhen_clause_list(this); + } +}; + +When_clause_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitWhen_clause_list(this); + } +}; + +When_clause_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitWhen_clause_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.When_clause_listContext = When_clause_listContext; + +PostgreSQLParser.prototype.when_clause_list = function() { + + var localctx = new When_clause_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1298, PostgreSQLParser.RULE_when_clause_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9529; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + this.state = 9528; + this.when_clause(); + this.state = 9531; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while(_la===PostgreSQLParser.WHEN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function When_clauseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_when_clause; + return this; +} + +When_clauseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +When_clauseContext.prototype.constructor = When_clauseContext; + +When_clauseContext.prototype.WHEN = function() { + return this.getToken(PostgreSQLParser.WHEN, 0); +}; + +When_clauseContext.prototype.a_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_exprContext); + } else { + return this.getTypedRuleContext(A_exprContext,i); + } +}; + +When_clauseContext.prototype.THEN = function() { + return this.getToken(PostgreSQLParser.THEN, 0); +}; + +When_clauseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterWhen_clause(this); + } +}; + +When_clauseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitWhen_clause(this); + } +}; + +When_clauseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitWhen_clause(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.When_clauseContext = When_clauseContext; + +PostgreSQLParser.prototype.when_clause = function() { + + var localctx = new When_clauseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1300, PostgreSQLParser.RULE_when_clause); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9533; + this.match(PostgreSQLParser.WHEN); + this.state = 9534; + this.a_expr(); + this.state = 9535; + this.match(PostgreSQLParser.THEN); + this.state = 9536; + this.a_expr(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Case_defaultContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_case_default; + return this; +} + +Case_defaultContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Case_defaultContext.prototype.constructor = Case_defaultContext; + +Case_defaultContext.prototype.ELSE = function() { + return this.getToken(PostgreSQLParser.ELSE, 0); +}; + +Case_defaultContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Case_defaultContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCase_default(this); + } +}; + +Case_defaultContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCase_default(this); + } +}; + +Case_defaultContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCase_default(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Case_defaultContext = Case_defaultContext; + +PostgreSQLParser.prototype.case_default = function() { + + var localctx = new Case_defaultContext(this, this._ctx, this.state); + this.enterRule(localctx, 1302, PostgreSQLParser.RULE_case_default); + try { + this.state = 9541; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ELSE: + this.enterOuterAlt(localctx, 1); + this.state = 9538; + this.match(PostgreSQLParser.ELSE); + this.state = 9539; + this.a_expr(); + break; + case PostgreSQLParser.END_P: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Case_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_case_arg; + return this; +} + +Case_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Case_argContext.prototype.constructor = Case_argContext; + +Case_argContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Case_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCase_arg(this); + } +}; + +Case_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCase_arg(this); + } +}; + +Case_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCase_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Case_argContext = Case_argContext; + +PostgreSQLParser.prototype.case_arg = function() { + + var localctx = new Case_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 1304, PostgreSQLParser.RULE_case_arg); + try { + this.state = 9545; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.Operator: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 9543; + this.a_expr(); + break; + case PostgreSQLParser.WHEN: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ColumnrefContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_columnref; + return this; +} + +ColumnrefContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ColumnrefContext.prototype.constructor = ColumnrefContext; + +ColumnrefContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +ColumnrefContext.prototype.indirection = function() { + return this.getTypedRuleContext(IndirectionContext,0); +}; + +ColumnrefContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterColumnref(this); + } +}; + +ColumnrefContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitColumnref(this); + } +}; + +ColumnrefContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitColumnref(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ColumnrefContext = ColumnrefContext; + +PostgreSQLParser.prototype.columnref = function() { + + var localctx = new ColumnrefContext(this, this._ctx, this.state); + this.enterRule(localctx, 1306, PostgreSQLParser.RULE_columnref); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9547; + this.colid(); + this.state = 9549; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,613,this._ctx); + if(la_===1) { + this.state = 9548; + this.indirection(); + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Indirection_elContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_indirection_el; + return this; +} + +Indirection_elContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Indirection_elContext.prototype.constructor = Indirection_elContext; + +Indirection_elContext.prototype.DOT = function() { + return this.getToken(PostgreSQLParser.DOT, 0); +}; + +Indirection_elContext.prototype.attr_name = function() { + return this.getTypedRuleContext(Attr_nameContext,0); +}; + +Indirection_elContext.prototype.STAR = function() { + return this.getToken(PostgreSQLParser.STAR, 0); +}; + +Indirection_elContext.prototype.OPEN_BRACKET = function() { + return this.getToken(PostgreSQLParser.OPEN_BRACKET, 0); +}; + +Indirection_elContext.prototype.CLOSE_BRACKET = function() { + return this.getToken(PostgreSQLParser.CLOSE_BRACKET, 0); +}; + +Indirection_elContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Indirection_elContext.prototype.opt_slice_bound = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Opt_slice_boundContext); + } else { + return this.getTypedRuleContext(Opt_slice_boundContext,i); + } +}; + +Indirection_elContext.prototype.COLON = function() { + return this.getToken(PostgreSQLParser.COLON, 0); +}; + +Indirection_elContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIndirection_el(this); + } +}; + +Indirection_elContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIndirection_el(this); + } +}; + +Indirection_elContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIndirection_el(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Indirection_elContext = Indirection_elContext; + +PostgreSQLParser.prototype.indirection_el = function() { + + var localctx = new Indirection_elContext(this, this._ctx, this.state); + this.enterRule(localctx, 1308, PostgreSQLParser.RULE_indirection_el); + try { + this.state = 9566; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.DOT: + this.enterOuterAlt(localctx, 1); + this.state = 9551; + this.match(PostgreSQLParser.DOT); + this.state = 9554; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.ALL: + case PostgreSQLParser.ANALYSE: + case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.AND: + case PostgreSQLParser.ANY: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.AS: + case PostgreSQLParser.ASC: + case PostgreSQLParser.ASYMMETRIC: + case PostgreSQLParser.BOTH: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.CHECK: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CREATE: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.DESC: + case PostgreSQLParser.DISTINCT: + case PostgreSQLParser.DO: + case PostgreSQLParser.ELSE: + case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.FOR: + case PostgreSQLParser.FOREIGN: + case PostgreSQLParser.FROM: + case PostgreSQLParser.GRANT: + case PostgreSQLParser.GROUP_P: + case PostgreSQLParser.HAVING: + case PostgreSQLParser.IN_P: + case PostgreSQLParser.INITIALLY: + case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.LATERAL_P: + case PostgreSQLParser.LEADING: + case PostgreSQLParser.LIMIT: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.OFFSET: + case PostgreSQLParser.ON: + case PostgreSQLParser.ONLY: + case PostgreSQLParser.OR: + case PostgreSQLParser.ORDER: + case PostgreSQLParser.PLACING: + case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.REFERENCES: + case PostgreSQLParser.RETURNING: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.SOME: + case PostgreSQLParser.SYMMETRIC: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.THEN: + case PostgreSQLParser.TO: + case PostgreSQLParser.TRAILING: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNION: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.USING: + case PostgreSQLParser.VARIADIC: + case PostgreSQLParser.WHEN: + case PostgreSQLParser.WHERE: + case PostgreSQLParser.WINDOW: + case PostgreSQLParser.WITH: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.END_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.state = 9552; + this.attr_name(); + break; + case PostgreSQLParser.STAR: + this.state = 9553; + this.match(PostgreSQLParser.STAR); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + case PostgreSQLParser.OPEN_BRACKET: + this.enterOuterAlt(localctx, 2); + this.state = 9556; + this.match(PostgreSQLParser.OPEN_BRACKET); + this.state = 9562; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,615,this._ctx); + switch(la_) { + case 1: + this.state = 9557; + this.a_expr(); + break; + + case 2: + this.state = 9558; + this.opt_slice_bound(); + this.state = 9559; + this.match(PostgreSQLParser.COLON); + this.state = 9560; + this.opt_slice_bound(); + break; + + } + this.state = 9564; + this.match(PostgreSQLParser.CLOSE_BRACKET); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_slice_boundContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_slice_bound; + return this; +} + +Opt_slice_boundContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_slice_boundContext.prototype.constructor = Opt_slice_boundContext; + +Opt_slice_boundContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Opt_slice_boundContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_slice_bound(this); + } +}; + +Opt_slice_boundContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_slice_bound(this); + } +}; + +Opt_slice_boundContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_slice_bound(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_slice_boundContext = Opt_slice_boundContext; + +PostgreSQLParser.prototype.opt_slice_bound = function() { + + var localctx = new Opt_slice_boundContext(this, this._ctx, this.state); + this.enterRule(localctx, 1310, PostgreSQLParser.RULE_opt_slice_bound); + try { + this.state = 9570; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.Operator: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 9568; + this.a_expr(); + break; + case PostgreSQLParser.CLOSE_BRACKET: + case PostgreSQLParser.COLON: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function IndirectionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_indirection; + return this; +} + +IndirectionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +IndirectionContext.prototype.constructor = IndirectionContext; + +IndirectionContext.prototype.indirection_el = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Indirection_elContext); + } else { + return this.getTypedRuleContext(Indirection_elContext,i); + } +}; + +IndirectionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIndirection(this); + } +}; + +IndirectionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIndirection(this); + } +}; + +IndirectionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIndirection(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.IndirectionContext = IndirectionContext; + +PostgreSQLParser.prototype.indirection = function() { + + var localctx = new IndirectionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1312, PostgreSQLParser.RULE_indirection); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9573; + this._errHandler.sync(this); + var _alt = 1; + do { + switch (_alt) { + case 1: + this.state = 9572; + this.indirection_el(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 9575; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,618, this._ctx); + } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER ); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_indirectionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_indirection; + return this; +} + +Opt_indirectionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_indirectionContext.prototype.constructor = Opt_indirectionContext; + +Opt_indirectionContext.prototype.indirection_el = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Indirection_elContext); + } else { + return this.getTypedRuleContext(Indirection_elContext,i); + } +}; + +Opt_indirectionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_indirection(this); + } +}; + +Opt_indirectionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_indirection(this); + } +}; + +Opt_indirectionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_indirection(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_indirectionContext = Opt_indirectionContext; + +PostgreSQLParser.prototype.opt_indirection = function() { + + var localctx = new Opt_indirectionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1314, PostgreSQLParser.RULE_opt_indirection); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9580; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,619,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 9577; + this.indirection_el(); + } + this.state = 9582; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,619,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_target_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_target_list; + return this; +} + +Opt_target_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_target_listContext.prototype.constructor = Opt_target_listContext; + +Opt_target_listContext.prototype.target_list = function() { + return this.getTypedRuleContext(Target_listContext,0); +}; + +Opt_target_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_target_list(this); + } +}; + +Opt_target_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_target_list(this); + } +}; + +Opt_target_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_target_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_target_listContext = Opt_target_listContext; + +PostgreSQLParser.prototype.opt_target_list = function() { + + var localctx = new Opt_target_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1316, PostgreSQLParser.RULE_opt_target_list); + try { + this.state = 9585; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,620,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9583; + this.target_list(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Target_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_target_list; + return this; +} + +Target_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Target_listContext.prototype.constructor = Target_listContext; + +Target_listContext.prototype.target_el = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Target_elContext); + } else { + return this.getTypedRuleContext(Target_elContext,i); + } +}; + +Target_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Target_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTarget_list(this); + } +}; + +Target_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTarget_list(this); + } +}; + +Target_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTarget_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Target_listContext = Target_listContext; + +PostgreSQLParser.prototype.target_list = function() { + + var localctx = new Target_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1318, PostgreSQLParser.RULE_target_list); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9587; + this.target_el(); + this.state = 9592; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,621,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 9588; + this.match(PostgreSQLParser.COMMA); + this.state = 9589; + this.target_el(); + } + this.state = 9594; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,621,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Target_elContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_target_el; + return this; +} + +Target_elContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Target_elContext.prototype.constructor = Target_elContext; + + + +Target_elContext.prototype.copyFrom = function(ctx) { + antlr4.ParserRuleContext.prototype.copyFrom.call(this, ctx); +}; + + +function Target_labelContext(parser, ctx) { + Target_elContext.call(this, parser); + Target_elContext.prototype.copyFrom.call(this, ctx); + return this; +} + +Target_labelContext.prototype = Object.create(Target_elContext.prototype); +Target_labelContext.prototype.constructor = Target_labelContext; + +PostgreSQLParser.Target_labelContext = Target_labelContext; + +Target_labelContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Target_labelContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Target_labelContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +Target_labelContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; +Target_labelContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTarget_label(this); + } +}; + +Target_labelContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTarget_label(this); + } +}; + +Target_labelContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTarget_label(this); + } else { + return visitor.visitChildren(this); + } +}; + + +function Target_starContext(parser, ctx) { + Target_elContext.call(this, parser); + Target_elContext.prototype.copyFrom.call(this, ctx); + return this; +} + +Target_starContext.prototype = Object.create(Target_elContext.prototype); +Target_starContext.prototype.constructor = Target_starContext; + +PostgreSQLParser.Target_starContext = Target_starContext; + +Target_starContext.prototype.STAR = function() { + return this.getToken(PostgreSQLParser.STAR, 0); +}; +Target_starContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterTarget_star(this); + } +}; + +Target_starContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitTarget_star(this); + } +}; + +Target_starContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitTarget_star(this); + } else { + return visitor.visitChildren(this); + } +}; + + + +PostgreSQLParser.Target_elContext = Target_elContext; + +PostgreSQLParser.prototype.target_el = function() { + + var localctx = new Target_elContext(this, this._ctx, this.state); + this.enterRule(localctx, 1320, PostgreSQLParser.RULE_target_el); + try { + this.state = 9603; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.Operator: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + localctx = new Target_labelContext(this, localctx); + this.enterOuterAlt(localctx, 1); + this.state = 9595; + this.a_expr(); + this.state = 9600; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,622,this._ctx); + switch(la_) { + case 1: + this.state = 9596; + this.match(PostgreSQLParser.AS); + this.state = 9597; + this.collabel(); + break; + + case 2: + this.state = 9598; + this.identifier(); + break; + + case 3: + break; + + } + break; + case PostgreSQLParser.STAR: + localctx = new Target_starContext(this, localctx); + this.enterOuterAlt(localctx, 2); + this.state = 9602; + this.match(PostgreSQLParser.STAR); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Qualified_name_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_qualified_name_list; + return this; +} + +Qualified_name_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Qualified_name_listContext.prototype.constructor = Qualified_name_listContext; + +Qualified_name_listContext.prototype.qualified_name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Qualified_nameContext); + } else { + return this.getTypedRuleContext(Qualified_nameContext,i); + } +}; + +Qualified_name_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Qualified_name_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterQualified_name_list(this); + } +}; + +Qualified_name_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitQualified_name_list(this); + } +}; + +Qualified_name_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitQualified_name_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Qualified_name_listContext = Qualified_name_listContext; + +PostgreSQLParser.prototype.qualified_name_list = function() { + + var localctx = new Qualified_name_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1322, PostgreSQLParser.RULE_qualified_name_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9605; + this.qualified_name(); + this.state = 9610; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 9606; + this.match(PostgreSQLParser.COMMA); + this.state = 9607; + this.qualified_name(); + this.state = 9612; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Qualified_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_qualified_name; + return this; +} + +Qualified_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Qualified_nameContext.prototype.constructor = Qualified_nameContext; + +Qualified_nameContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Qualified_nameContext.prototype.indirection = function() { + return this.getTypedRuleContext(IndirectionContext,0); +}; + +Qualified_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterQualified_name(this); + } +}; + +Qualified_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitQualified_name(this); + } +}; + +Qualified_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitQualified_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Qualified_nameContext = Qualified_nameContext; + +PostgreSQLParser.prototype.qualified_name = function() { + + var localctx = new Qualified_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1324, PostgreSQLParser.RULE_qualified_name); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9613; + this.colid(); + this.state = 9615; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OPEN_BRACKET || _la===PostgreSQLParser.DOT) { + this.state = 9614; + this.indirection(); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Name_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_name_list; + return this; +} + +Name_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Name_listContext.prototype.constructor = Name_listContext; + +Name_listContext.prototype.name = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(NameContext); + } else { + return this.getTypedRuleContext(NameContext,i); + } +}; + +Name_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Name_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterName_list(this); + } +}; + +Name_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitName_list(this); + } +}; + +Name_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitName_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Name_listContext = Name_listContext; + +PostgreSQLParser.prototype.name_list = function() { + + var localctx = new Name_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1326, PostgreSQLParser.RULE_name_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9617; + this.name(); + this.state = 9622; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 9618; + this.match(PostgreSQLParser.COMMA); + this.state = 9619; + this.name(); + this.state = 9624; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function NameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_name; + return this; +} + +NameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +NameContext.prototype.constructor = NameContext; + +NameContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +NameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterName(this); + } +}; + +NameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitName(this); + } +}; + +NameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitName(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.NameContext = NameContext; + +PostgreSQLParser.prototype.name = function() { + + var localctx = new NameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1328, PostgreSQLParser.RULE_name); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9625; + this.colid(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Attr_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_attr_name; + return this; +} + +Attr_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Attr_nameContext.prototype.constructor = Attr_nameContext; + +Attr_nameContext.prototype.collabel = function() { + return this.getTypedRuleContext(CollabelContext,0); +}; + +Attr_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAttr_name(this); + } +}; + +Attr_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAttr_name(this); + } +}; + +Attr_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAttr_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Attr_nameContext = Attr_nameContext; + +PostgreSQLParser.prototype.attr_name = function() { + + var localctx = new Attr_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1330, PostgreSQLParser.RULE_attr_name); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9627; + this.collabel(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function File_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_file_name; + return this; +} + +File_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +File_nameContext.prototype.constructor = File_nameContext; + +File_nameContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +File_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFile_name(this); + } +}; + +File_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFile_name(this); + } +}; + +File_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFile_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.File_nameContext = File_nameContext; + +PostgreSQLParser.prototype.file_name = function() { + + var localctx = new File_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1332, PostgreSQLParser.RULE_file_name); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9629; + this.sconst(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Func_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_func_name; + return this; +} + +Func_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Func_nameContext.prototype.constructor = Func_nameContext; + +Func_nameContext.prototype.type_function_name = function() { + return this.getTypedRuleContext(Type_function_nameContext,0); +}; + +Func_nameContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Func_nameContext.prototype.indirection = function() { + return this.getTypedRuleContext(IndirectionContext,0); +}; + +Func_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFunc_name(this); + } +}; + +Func_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFunc_name(this); + } +}; + +Func_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFunc_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Func_nameContext = Func_nameContext; + +PostgreSQLParser.prototype.func_name = function() { + + var localctx = new Func_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1334, PostgreSQLParser.RULE_func_name); + try { + this.state = 9635; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,627,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9631; + this.type_function_name(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9632; + this.colid(); + this.state = 9633; + this.indirection(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AexprconstContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_aexprconst; + return this; +} + +AexprconstContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AexprconstContext.prototype.constructor = AexprconstContext; + +AexprconstContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +AexprconstContext.prototype.fconst = function() { + return this.getTypedRuleContext(FconstContext,0); +}; + +AexprconstContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +AexprconstContext.prototype.bconst = function() { + return this.getTypedRuleContext(BconstContext,0); +}; + +AexprconstContext.prototype.xconst = function() { + return this.getTypedRuleContext(XconstContext,0); +}; + +AexprconstContext.prototype.func_name = function() { + return this.getTypedRuleContext(Func_nameContext,0); +}; + +AexprconstContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +AexprconstContext.prototype.func_arg_list = function() { + return this.getTypedRuleContext(Func_arg_listContext,0); +}; + +AexprconstContext.prototype.opt_sort_clause = function() { + return this.getTypedRuleContext(Opt_sort_clauseContext,0); +}; + +AexprconstContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +AexprconstContext.prototype.consttypename = function() { + return this.getTypedRuleContext(ConsttypenameContext,0); +}; + +AexprconstContext.prototype.constinterval = function() { + return this.getTypedRuleContext(ConstintervalContext,0); +}; + +AexprconstContext.prototype.opt_interval = function() { + return this.getTypedRuleContext(Opt_intervalContext,0); +}; + +AexprconstContext.prototype.TRUE_P = function() { + return this.getToken(PostgreSQLParser.TRUE_P, 0); +}; + +AexprconstContext.prototype.FALSE_P = function() { + return this.getToken(PostgreSQLParser.FALSE_P, 0); +}; + +AexprconstContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +AexprconstContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAexprconst(this); + } +}; + +AexprconstContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAexprconst(this); + } +}; + +AexprconstContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAexprconst(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AexprconstContext = AexprconstContext; + +PostgreSQLParser.prototype.aexprconst = function() { + + var localctx = new AexprconstContext(this, this._ctx, this.state); + this.enterRule(localctx, 1336, PostgreSQLParser.RULE_aexprconst); + try { + this.state = 9669; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,630,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9637; + this.iconst(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9638; + this.fconst(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9639; + this.sconst(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9640; + this.bconst(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 9641; + this.xconst(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 9642; + this.func_name(); + this.state = 9650; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.state = 9643; + this.sconst(); + break; + case PostgreSQLParser.OPEN_PAREN: + this.state = 9644; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9645; + this.func_arg_list(); + this.state = 9646; + this.opt_sort_clause(); + this.state = 9647; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 9648; + this.sconst(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 9652; + this.consttypename(); + this.state = 9653; + this.sconst(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 9655; + this.constinterval(); + this.state = 9664; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.EscapeStringConstant: + this.state = 9656; + this.sconst(); + this.state = 9657; + this.opt_interval(); + break; + case PostgreSQLParser.OPEN_PAREN: + this.state = 9659; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9660; + this.iconst(); + this.state = 9661; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 9662; + this.sconst(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 9666; + this.match(PostgreSQLParser.TRUE_P); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 9667; + this.match(PostgreSQLParser.FALSE_P); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 9668; + this.match(PostgreSQLParser.NULL_P); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function XconstContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_xconst; + return this; +} + +XconstContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +XconstContext.prototype.constructor = XconstContext; + +XconstContext.prototype.HexadecimalStringConstant = function() { + return this.getToken(PostgreSQLParser.HexadecimalStringConstant, 0); +}; + +XconstContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterXconst(this); + } +}; + +XconstContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitXconst(this); + } +}; + +XconstContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitXconst(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.XconstContext = XconstContext; + +PostgreSQLParser.prototype.xconst = function() { + + var localctx = new XconstContext(this, this._ctx, this.state); + this.enterRule(localctx, 1338, PostgreSQLParser.RULE_xconst); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9671; + this.match(PostgreSQLParser.HexadecimalStringConstant); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function BconstContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_bconst; + return this; +} + +BconstContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +BconstContext.prototype.constructor = BconstContext; + +BconstContext.prototype.BinaryStringConstant = function() { + return this.getToken(PostgreSQLParser.BinaryStringConstant, 0); +}; + +BconstContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterBconst(this); + } +}; + +BconstContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitBconst(this); + } +}; + +BconstContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitBconst(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.BconstContext = BconstContext; + +PostgreSQLParser.prototype.bconst = function() { + + var localctx = new BconstContext(this, this._ctx, this.state); + this.enterRule(localctx, 1340, PostgreSQLParser.RULE_bconst); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9673; + this.match(PostgreSQLParser.BinaryStringConstant); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function FconstContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_fconst; + return this; +} + +FconstContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +FconstContext.prototype.constructor = FconstContext; + +FconstContext.prototype.Numeric = function() { + return this.getToken(PostgreSQLParser.Numeric, 0); +}; + +FconstContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFconst(this); + } +}; + +FconstContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFconst(this); + } +}; + +FconstContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFconst(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.FconstContext = FconstContext; + +PostgreSQLParser.prototype.fconst = function() { + + var localctx = new FconstContext(this, this._ctx, this.state); + this.enterRule(localctx, 1342, PostgreSQLParser.RULE_fconst); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9675; + this.match(PostgreSQLParser.Numeric); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function IconstContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_iconst; + return this; +} + +IconstContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +IconstContext.prototype.constructor = IconstContext; + +IconstContext.prototype.Integral = function() { + return this.getToken(PostgreSQLParser.Integral, 0); +}; + +IconstContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIconst(this); + } +}; + +IconstContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIconst(this); + } +}; + +IconstContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIconst(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.IconstContext = IconstContext; + +PostgreSQLParser.prototype.iconst = function() { + + var localctx = new IconstContext(this, this._ctx, this.state); + this.enterRule(localctx, 1344, PostgreSQLParser.RULE_iconst); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9677; + this.match(PostgreSQLParser.Integral); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function SconstContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_sconst; + return this; +} + +SconstContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +SconstContext.prototype.constructor = SconstContext; + +SconstContext.prototype.anysconst = function() { + return this.getTypedRuleContext(AnysconstContext,0); +}; + +SconstContext.prototype.opt_uescape = function() { + return this.getTypedRuleContext(Opt_uescapeContext,0); +}; + +SconstContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSconst(this); + } +}; + +SconstContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSconst(this); + } +}; + +SconstContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSconst(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.SconstContext = SconstContext; + +PostgreSQLParser.prototype.sconst = function() { + + var localctx = new SconstContext(this, this._ctx, this.state); + this.enterRule(localctx, 1346, PostgreSQLParser.RULE_sconst); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9679; + this.anysconst(); + this.state = 9680; + this.opt_uescape(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function AnysconstContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_anysconst; + return this; +} + +AnysconstContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +AnysconstContext.prototype.constructor = AnysconstContext; + +AnysconstContext.prototype.StringConstant = function() { + return this.getToken(PostgreSQLParser.StringConstant, 0); +}; + +AnysconstContext.prototype.UnicodeEscapeStringConstant = function() { + return this.getToken(PostgreSQLParser.UnicodeEscapeStringConstant, 0); +}; + +AnysconstContext.prototype.BeginDollarStringConstant = function() { + return this.getToken(PostgreSQLParser.BeginDollarStringConstant, 0); +}; + +AnysconstContext.prototype.EndDollarStringConstant = function() { + return this.getToken(PostgreSQLParser.EndDollarStringConstant, 0); +}; + +AnysconstContext.prototype.DollarText = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.DollarText); + } else { + return this.getToken(PostgreSQLParser.DollarText, i); + } +}; + + +AnysconstContext.prototype.EscapeStringConstant = function() { + return this.getToken(PostgreSQLParser.EscapeStringConstant, 0); +}; + +AnysconstContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAnysconst(this); + } +}; + +AnysconstContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAnysconst(this); + } +}; + +AnysconstContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAnysconst(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.AnysconstContext = AnysconstContext; + +PostgreSQLParser.prototype.anysconst = function() { + + var localctx = new AnysconstContext(this, this._ctx, this.state); + this.enterRule(localctx, 1348, PostgreSQLParser.RULE_anysconst); + var _la = 0; // Token type + try { + this.state = 9693; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.StringConstant: + this.enterOuterAlt(localctx, 1); + this.state = 9682; + this.match(PostgreSQLParser.StringConstant); + break; + case PostgreSQLParser.UnicodeEscapeStringConstant: + this.enterOuterAlt(localctx, 2); + this.state = 9683; + this.match(PostgreSQLParser.UnicodeEscapeStringConstant); + break; + case PostgreSQLParser.BeginDollarStringConstant: + this.enterOuterAlt(localctx, 3); + this.state = 9684; + this.match(PostgreSQLParser.BeginDollarStringConstant); + this.state = 9688; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.DollarText) { + this.state = 9685; + this.match(PostgreSQLParser.DollarText); + this.state = 9690; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 9691; + this.match(PostgreSQLParser.EndDollarStringConstant); + break; + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 4); + this.state = 9692; + this.match(PostgreSQLParser.EscapeStringConstant); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_uescapeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_uescape; + return this; +} + +Opt_uescapeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_uescapeContext.prototype.constructor = Opt_uescapeContext; + +Opt_uescapeContext.prototype.UESCAPE = function() { + return this.getToken(PostgreSQLParser.UESCAPE, 0); +}; + +Opt_uescapeContext.prototype.anysconst = function() { + return this.getTypedRuleContext(AnysconstContext,0); +}; + +Opt_uescapeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_uescape(this); + } +}; + +Opt_uescapeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_uescape(this); + } +}; + +Opt_uescapeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_uescape(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_uescapeContext = Opt_uescapeContext; + +PostgreSQLParser.prototype.opt_uescape = function() { + + var localctx = new Opt_uescapeContext(this, this._ctx, this.state); + this.enterRule(localctx, 1350, PostgreSQLParser.RULE_opt_uescape); + try { + this.state = 9698; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,633,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9695; + this.match(PostgreSQLParser.UESCAPE); + this.state = 9696; + this.anysconst(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function SignediconstContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_signediconst; + return this; +} + +SignediconstContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +SignediconstContext.prototype.constructor = SignediconstContext; + +SignediconstContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +SignediconstContext.prototype.PLUS = function() { + return this.getToken(PostgreSQLParser.PLUS, 0); +}; + +SignediconstContext.prototype.MINUS = function() { + return this.getToken(PostgreSQLParser.MINUS, 0); +}; + +SignediconstContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSignediconst(this); + } +}; + +SignediconstContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSignediconst(this); + } +}; + +SignediconstContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSignediconst(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.SignediconstContext = SignediconstContext; + +PostgreSQLParser.prototype.signediconst = function() { + + var localctx = new SignediconstContext(this, this._ctx, this.state); + this.enterRule(localctx, 1352, PostgreSQLParser.RULE_signediconst); + try { + this.state = 9705; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.Integral: + this.enterOuterAlt(localctx, 1); + this.state = 9700; + this.iconst(); + break; + case PostgreSQLParser.PLUS: + this.enterOuterAlt(localctx, 2); + this.state = 9701; + this.match(PostgreSQLParser.PLUS); + this.state = 9702; + this.iconst(); + break; + case PostgreSQLParser.MINUS: + this.enterOuterAlt(localctx, 3); + this.state = 9703; + this.match(PostgreSQLParser.MINUS); + this.state = 9704; + this.iconst(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RoleidContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_roleid; + return this; +} + +RoleidContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RoleidContext.prototype.constructor = RoleidContext; + +RoleidContext.prototype.rolespec = function() { + return this.getTypedRuleContext(RolespecContext,0); +}; + +RoleidContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRoleid(this); + } +}; + +RoleidContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRoleid(this); + } +}; + +RoleidContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRoleid(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RoleidContext = RoleidContext; + +PostgreSQLParser.prototype.roleid = function() { + + var localctx = new RoleidContext(this, this._ctx, this.state); + this.enterRule(localctx, 1354, PostgreSQLParser.RULE_roleid); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9707; + this.rolespec(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function RolespecContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_rolespec; + return this; +} + +RolespecContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +RolespecContext.prototype.constructor = RolespecContext; + +RolespecContext.prototype.nonreservedword = function() { + return this.getTypedRuleContext(NonreservedwordContext,0); +}; + +RolespecContext.prototype.CURRENT_USER = function() { + return this.getToken(PostgreSQLParser.CURRENT_USER, 0); +}; + +RolespecContext.prototype.SESSION_USER = function() { + return this.getToken(PostgreSQLParser.SESSION_USER, 0); +}; + +RolespecContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRolespec(this); + } +}; + +RolespecContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRolespec(this); + } +}; + +RolespecContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRolespec(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.RolespecContext = RolespecContext; + +PostgreSQLParser.prototype.rolespec = function() { + + var localctx = new RolespecContext(this, this._ctx, this.state); + this.enterRule(localctx, 1356, PostgreSQLParser.RULE_rolespec); + try { + this.state = 9712; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 9709; + this.nonreservedword(); + break; + case PostgreSQLParser.CURRENT_USER: + this.enterOuterAlt(localctx, 2); + this.state = 9710; + this.match(PostgreSQLParser.CURRENT_USER); + break; + case PostgreSQLParser.SESSION_USER: + this.enterOuterAlt(localctx, 3); + this.state = 9711; + this.match(PostgreSQLParser.SESSION_USER); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Role_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_role_list; + return this; +} + +Role_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Role_listContext.prototype.constructor = Role_listContext; + +Role_listContext.prototype.rolespec = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(RolespecContext); + } else { + return this.getTypedRuleContext(RolespecContext,i); + } +}; + +Role_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Role_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterRole_list(this); + } +}; + +Role_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitRole_list(this); + } +}; + +Role_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitRole_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Role_listContext = Role_listContext; + +PostgreSQLParser.prototype.role_list = function() { + + var localctx = new Role_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1358, PostgreSQLParser.RULE_role_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9714; + this.rolespec(); + this.state = 9719; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 9715; + this.match(PostgreSQLParser.COMMA); + this.state = 9716; + this.rolespec(); + this.state = 9721; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function ColidContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_colid; + return this; +} + +ColidContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +ColidContext.prototype.constructor = ColidContext; + +ColidContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +ColidContext.prototype.unreserved_keyword = function() { + return this.getTypedRuleContext(Unreserved_keywordContext,0); +}; + +ColidContext.prototype.col_name_keyword = function() { + return this.getTypedRuleContext(Col_name_keywordContext,0); +}; + +ColidContext.prototype.plsql_unreserved_keyword = function() { + return this.getTypedRuleContext(Plsql_unreserved_keywordContext,0); +}; + +ColidContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterColid(this); + } +}; + +ColidContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitColid(this); + } +}; + +ColidContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitColid(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.ColidContext = ColidContext; + +PostgreSQLParser.prototype.colid = function() { + + var localctx = new ColidContext(this, this._ctx, this.state); + this.enterRule(localctx, 1360, PostgreSQLParser.RULE_colid); + try { + this.state = 9726; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,637,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9722; + this.identifier(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9723; + this.unreserved_keyword(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9724; + this.col_name_keyword(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9725; + this.plsql_unreserved_keyword(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Type_function_nameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_type_function_name; + return this; +} + +Type_function_nameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Type_function_nameContext.prototype.constructor = Type_function_nameContext; + +Type_function_nameContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +Type_function_nameContext.prototype.unreserved_keyword = function() { + return this.getTypedRuleContext(Unreserved_keywordContext,0); +}; + +Type_function_nameContext.prototype.plsql_unreserved_keyword = function() { + return this.getTypedRuleContext(Plsql_unreserved_keywordContext,0); +}; + +Type_function_nameContext.prototype.type_func_name_keyword = function() { + return this.getTypedRuleContext(Type_func_name_keywordContext,0); +}; + +Type_function_nameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterType_function_name(this); + } +}; + +Type_function_nameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitType_function_name(this); + } +}; + +Type_function_nameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitType_function_name(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Type_function_nameContext = Type_function_nameContext; + +PostgreSQLParser.prototype.type_function_name = function() { + + var localctx = new Type_function_nameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1362, PostgreSQLParser.RULE_type_function_name); + try { + this.state = 9732; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,638,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9728; + this.identifier(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9729; + this.unreserved_keyword(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9730; + this.plsql_unreserved_keyword(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9731; + this.type_func_name_keyword(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function NonreservedwordContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_nonreservedword; + return this; +} + +NonreservedwordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +NonreservedwordContext.prototype.constructor = NonreservedwordContext; + +NonreservedwordContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +NonreservedwordContext.prototype.unreserved_keyword = function() { + return this.getTypedRuleContext(Unreserved_keywordContext,0); +}; + +NonreservedwordContext.prototype.col_name_keyword = function() { + return this.getTypedRuleContext(Col_name_keywordContext,0); +}; + +NonreservedwordContext.prototype.type_func_name_keyword = function() { + return this.getTypedRuleContext(Type_func_name_keywordContext,0); +}; + +NonreservedwordContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterNonreservedword(this); + } +}; + +NonreservedwordContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitNonreservedword(this); + } +}; + +NonreservedwordContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitNonreservedword(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.NonreservedwordContext = NonreservedwordContext; + +PostgreSQLParser.prototype.nonreservedword = function() { + + var localctx = new NonreservedwordContext(this, this._ctx, this.state); + this.enterRule(localctx, 1364, PostgreSQLParser.RULE_nonreservedword); + try { + this.state = 9738; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,639,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9734; + this.identifier(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9735; + this.unreserved_keyword(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9736; + this.col_name_keyword(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9737; + this.type_func_name_keyword(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function CollabelContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_collabel; + return this; +} + +CollabelContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +CollabelContext.prototype.constructor = CollabelContext; + +CollabelContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +CollabelContext.prototype.plsql_unreserved_keyword = function() { + return this.getTypedRuleContext(Plsql_unreserved_keywordContext,0); +}; + +CollabelContext.prototype.unreserved_keyword = function() { + return this.getTypedRuleContext(Unreserved_keywordContext,0); +}; + +CollabelContext.prototype.col_name_keyword = function() { + return this.getTypedRuleContext(Col_name_keywordContext,0); +}; + +CollabelContext.prototype.type_func_name_keyword = function() { + return this.getTypedRuleContext(Type_func_name_keywordContext,0); +}; + +CollabelContext.prototype.reserved_keyword = function() { + return this.getTypedRuleContext(Reserved_keywordContext,0); +}; + +CollabelContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCollabel(this); + } +}; + +CollabelContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCollabel(this); + } +}; + +CollabelContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCollabel(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.CollabelContext = CollabelContext; + +PostgreSQLParser.prototype.collabel = function() { + + var localctx = new CollabelContext(this, this._ctx, this.state); + this.enterRule(localctx, 1366, PostgreSQLParser.RULE_collabel); + try { + this.state = 9746; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,640,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9740; + this.identifier(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9741; + this.plsql_unreserved_keyword(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9742; + this.unreserved_keyword(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9743; + this.col_name_keyword(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 9744; + this.type_func_name_keyword(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 9745; + this.reserved_keyword(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function IdentifierContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_identifier; + return this; +} + +IdentifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +IdentifierContext.prototype.constructor = IdentifierContext; + +IdentifierContext.prototype.Identifier = function() { + return this.getToken(PostgreSQLParser.Identifier, 0); +}; + +IdentifierContext.prototype.opt_uescape = function() { + return this.getTypedRuleContext(Opt_uescapeContext,0); +}; + +IdentifierContext.prototype.QuotedIdentifier = function() { + return this.getToken(PostgreSQLParser.QuotedIdentifier, 0); +}; + +IdentifierContext.prototype.UnicodeQuotedIdentifier = function() { + return this.getToken(PostgreSQLParser.UnicodeQuotedIdentifier, 0); +}; + +IdentifierContext.prototype.plsqlvariablename = function() { + return this.getTypedRuleContext(PlsqlvariablenameContext,0); +}; + +IdentifierContext.prototype.plsqlidentifier = function() { + return this.getTypedRuleContext(PlsqlidentifierContext,0); +}; + +IdentifierContext.prototype.plsql_unreserved_keyword = function() { + return this.getTypedRuleContext(Plsql_unreserved_keywordContext,0); +}; + +IdentifierContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterIdentifier(this); + } +}; + +IdentifierContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitIdentifier(this); + } +}; + +IdentifierContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitIdentifier(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.IdentifierContext = IdentifierContext; + +PostgreSQLParser.prototype.identifier = function() { + + var localctx = new IdentifierContext(this, this._ctx, this.state); + this.enterRule(localctx, 1368, PostgreSQLParser.RULE_identifier); + try { + this.state = 9755; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.Identifier: + this.enterOuterAlt(localctx, 1); + this.state = 9748; + this.match(PostgreSQLParser.Identifier); + this.state = 9749; + this.opt_uescape(); + break; + case PostgreSQLParser.QuotedIdentifier: + this.enterOuterAlt(localctx, 2); + this.state = 9750; + this.match(PostgreSQLParser.QuotedIdentifier); + break; + case PostgreSQLParser.UnicodeQuotedIdentifier: + this.enterOuterAlt(localctx, 3); + this.state = 9751; + this.match(PostgreSQLParser.UnicodeQuotedIdentifier); + break; + case PostgreSQLParser.PLSQLVARIABLENAME: + this.enterOuterAlt(localctx, 4); + this.state = 9752; + this.plsqlvariablename(); + break; + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 5); + this.state = 9753; + this.plsqlidentifier(); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RESET: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SET: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + this.enterOuterAlt(localctx, 6); + this.state = 9754; + this.plsql_unreserved_keyword(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function PlsqlidentifierContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_plsqlidentifier; + return this; +} + +PlsqlidentifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +PlsqlidentifierContext.prototype.constructor = PlsqlidentifierContext; + +PlsqlidentifierContext.prototype.PLSQLIDENTIFIER = function() { + return this.getToken(PostgreSQLParser.PLSQLIDENTIFIER, 0); +}; + +PlsqlidentifierContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPlsqlidentifier(this); + } +}; + +PlsqlidentifierContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPlsqlidentifier(this); + } +}; + +PlsqlidentifierContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPlsqlidentifier(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.PlsqlidentifierContext = PlsqlidentifierContext; + +PostgreSQLParser.prototype.plsqlidentifier = function() { + + var localctx = new PlsqlidentifierContext(this, this._ctx, this.state); + this.enterRule(localctx, 1370, PostgreSQLParser.RULE_plsqlidentifier); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9757; + this.match(PostgreSQLParser.PLSQLIDENTIFIER); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Unreserved_keywordContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_unreserved_keyword; + return this; +} + +Unreserved_keywordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Unreserved_keywordContext.prototype.constructor = Unreserved_keywordContext; + +Unreserved_keywordContext.prototype.ABORT_P = function() { + return this.getToken(PostgreSQLParser.ABORT_P, 0); +}; + +Unreserved_keywordContext.prototype.ABSOLUTE_P = function() { + return this.getToken(PostgreSQLParser.ABSOLUTE_P, 0); +}; + +Unreserved_keywordContext.prototype.ACCESS = function() { + return this.getToken(PostgreSQLParser.ACCESS, 0); +}; + +Unreserved_keywordContext.prototype.ACTION = function() { + return this.getToken(PostgreSQLParser.ACTION, 0); +}; + +Unreserved_keywordContext.prototype.ADD_P = function() { + return this.getToken(PostgreSQLParser.ADD_P, 0); +}; + +Unreserved_keywordContext.prototype.ADMIN = function() { + return this.getToken(PostgreSQLParser.ADMIN, 0); +}; + +Unreserved_keywordContext.prototype.AFTER = function() { + return this.getToken(PostgreSQLParser.AFTER, 0); +}; + +Unreserved_keywordContext.prototype.AGGREGATE = function() { + return this.getToken(PostgreSQLParser.AGGREGATE, 0); +}; + +Unreserved_keywordContext.prototype.ALSO = function() { + return this.getToken(PostgreSQLParser.ALSO, 0); +}; + +Unreserved_keywordContext.prototype.ALTER = function() { + return this.getToken(PostgreSQLParser.ALTER, 0); +}; + +Unreserved_keywordContext.prototype.ALWAYS = function() { + return this.getToken(PostgreSQLParser.ALWAYS, 0); +}; + +Unreserved_keywordContext.prototype.ASSERTION = function() { + return this.getToken(PostgreSQLParser.ASSERTION, 0); +}; + +Unreserved_keywordContext.prototype.ASSIGNMENT = function() { + return this.getToken(PostgreSQLParser.ASSIGNMENT, 0); +}; + +Unreserved_keywordContext.prototype.AT = function() { + return this.getToken(PostgreSQLParser.AT, 0); +}; + +Unreserved_keywordContext.prototype.ATTACH = function() { + return this.getToken(PostgreSQLParser.ATTACH, 0); +}; + +Unreserved_keywordContext.prototype.ATTRIBUTE = function() { + return this.getToken(PostgreSQLParser.ATTRIBUTE, 0); +}; + +Unreserved_keywordContext.prototype.BACKWARD = function() { + return this.getToken(PostgreSQLParser.BACKWARD, 0); +}; + +Unreserved_keywordContext.prototype.BEFORE = function() { + return this.getToken(PostgreSQLParser.BEFORE, 0); +}; + +Unreserved_keywordContext.prototype.BEGIN_P = function() { + return this.getToken(PostgreSQLParser.BEGIN_P, 0); +}; + +Unreserved_keywordContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Unreserved_keywordContext.prototype.CACHE = function() { + return this.getToken(PostgreSQLParser.CACHE, 0); +}; + +Unreserved_keywordContext.prototype.CALL = function() { + return this.getToken(PostgreSQLParser.CALL, 0); +}; + +Unreserved_keywordContext.prototype.CALLED = function() { + return this.getToken(PostgreSQLParser.CALLED, 0); +}; + +Unreserved_keywordContext.prototype.CASCADE = function() { + return this.getToken(PostgreSQLParser.CASCADE, 0); +}; + +Unreserved_keywordContext.prototype.CASCADED = function() { + return this.getToken(PostgreSQLParser.CASCADED, 0); +}; + +Unreserved_keywordContext.prototype.CATALOG = function() { + return this.getToken(PostgreSQLParser.CATALOG, 0); +}; + +Unreserved_keywordContext.prototype.CHAIN = function() { + return this.getToken(PostgreSQLParser.CHAIN, 0); +}; + +Unreserved_keywordContext.prototype.CHARACTERISTICS = function() { + return this.getToken(PostgreSQLParser.CHARACTERISTICS, 0); +}; + +Unreserved_keywordContext.prototype.CHECKPOINT = function() { + return this.getToken(PostgreSQLParser.CHECKPOINT, 0); +}; + +Unreserved_keywordContext.prototype.CLASS = function() { + return this.getToken(PostgreSQLParser.CLASS, 0); +}; + +Unreserved_keywordContext.prototype.CLOSE = function() { + return this.getToken(PostgreSQLParser.CLOSE, 0); +}; + +Unreserved_keywordContext.prototype.CLUSTER = function() { + return this.getToken(PostgreSQLParser.CLUSTER, 0); +}; + +Unreserved_keywordContext.prototype.COLUMNS = function() { + return this.getToken(PostgreSQLParser.COLUMNS, 0); +}; + +Unreserved_keywordContext.prototype.COMMENT = function() { + return this.getToken(PostgreSQLParser.COMMENT, 0); +}; + +Unreserved_keywordContext.prototype.COMMENTS = function() { + return this.getToken(PostgreSQLParser.COMMENTS, 0); +}; + +Unreserved_keywordContext.prototype.COMMIT = function() { + return this.getToken(PostgreSQLParser.COMMIT, 0); +}; + +Unreserved_keywordContext.prototype.COMMITTED = function() { + return this.getToken(PostgreSQLParser.COMMITTED, 0); +}; + +Unreserved_keywordContext.prototype.CONFIGURATION = function() { + return this.getToken(PostgreSQLParser.CONFIGURATION, 0); +}; + +Unreserved_keywordContext.prototype.CONFLICT = function() { + return this.getToken(PostgreSQLParser.CONFLICT, 0); +}; + +Unreserved_keywordContext.prototype.CONNECTION = function() { + return this.getToken(PostgreSQLParser.CONNECTION, 0); +}; + +Unreserved_keywordContext.prototype.CONSTRAINTS = function() { + return this.getToken(PostgreSQLParser.CONSTRAINTS, 0); +}; + +Unreserved_keywordContext.prototype.CONTENT_P = function() { + return this.getToken(PostgreSQLParser.CONTENT_P, 0); +}; + +Unreserved_keywordContext.prototype.CONTINUE_P = function() { + return this.getToken(PostgreSQLParser.CONTINUE_P, 0); +}; + +Unreserved_keywordContext.prototype.CONVERSION_P = function() { + return this.getToken(PostgreSQLParser.CONVERSION_P, 0); +}; + +Unreserved_keywordContext.prototype.COPY = function() { + return this.getToken(PostgreSQLParser.COPY, 0); +}; + +Unreserved_keywordContext.prototype.COST = function() { + return this.getToken(PostgreSQLParser.COST, 0); +}; + +Unreserved_keywordContext.prototype.CSV = function() { + return this.getToken(PostgreSQLParser.CSV, 0); +}; + +Unreserved_keywordContext.prototype.CUBE = function() { + return this.getToken(PostgreSQLParser.CUBE, 0); +}; + +Unreserved_keywordContext.prototype.CURRENT_P = function() { + return this.getToken(PostgreSQLParser.CURRENT_P, 0); +}; + +Unreserved_keywordContext.prototype.CURSOR = function() { + return this.getToken(PostgreSQLParser.CURSOR, 0); +}; + +Unreserved_keywordContext.prototype.CYCLE = function() { + return this.getToken(PostgreSQLParser.CYCLE, 0); +}; + +Unreserved_keywordContext.prototype.DATA_P = function() { + return this.getToken(PostgreSQLParser.DATA_P, 0); +}; + +Unreserved_keywordContext.prototype.DATABASE = function() { + return this.getToken(PostgreSQLParser.DATABASE, 0); +}; + +Unreserved_keywordContext.prototype.DAY_P = function() { + return this.getToken(PostgreSQLParser.DAY_P, 0); +}; + +Unreserved_keywordContext.prototype.DEALLOCATE = function() { + return this.getToken(PostgreSQLParser.DEALLOCATE, 0); +}; + +Unreserved_keywordContext.prototype.DECLARE = function() { + return this.getToken(PostgreSQLParser.DECLARE, 0); +}; + +Unreserved_keywordContext.prototype.DEFAULTS = function() { + return this.getToken(PostgreSQLParser.DEFAULTS, 0); +}; + +Unreserved_keywordContext.prototype.DEFERRED = function() { + return this.getToken(PostgreSQLParser.DEFERRED, 0); +}; + +Unreserved_keywordContext.prototype.DEFINER = function() { + return this.getToken(PostgreSQLParser.DEFINER, 0); +}; + +Unreserved_keywordContext.prototype.DELETE_P = function() { + return this.getToken(PostgreSQLParser.DELETE_P, 0); +}; + +Unreserved_keywordContext.prototype.DELIMITER = function() { + return this.getToken(PostgreSQLParser.DELIMITER, 0); +}; + +Unreserved_keywordContext.prototype.DELIMITERS = function() { + return this.getToken(PostgreSQLParser.DELIMITERS, 0); +}; + +Unreserved_keywordContext.prototype.DEPENDS = function() { + return this.getToken(PostgreSQLParser.DEPENDS, 0); +}; + +Unreserved_keywordContext.prototype.DETACH = function() { + return this.getToken(PostgreSQLParser.DETACH, 0); +}; + +Unreserved_keywordContext.prototype.DICTIONARY = function() { + return this.getToken(PostgreSQLParser.DICTIONARY, 0); +}; + +Unreserved_keywordContext.prototype.DISABLE_P = function() { + return this.getToken(PostgreSQLParser.DISABLE_P, 0); +}; + +Unreserved_keywordContext.prototype.DISCARD = function() { + return this.getToken(PostgreSQLParser.DISCARD, 0); +}; + +Unreserved_keywordContext.prototype.DOCUMENT_P = function() { + return this.getToken(PostgreSQLParser.DOCUMENT_P, 0); +}; + +Unreserved_keywordContext.prototype.DOMAIN_P = function() { + return this.getToken(PostgreSQLParser.DOMAIN_P, 0); +}; + +Unreserved_keywordContext.prototype.DOUBLE_P = function() { + return this.getToken(PostgreSQLParser.DOUBLE_P, 0); +}; + +Unreserved_keywordContext.prototype.DROP = function() { + return this.getToken(PostgreSQLParser.DROP, 0); +}; + +Unreserved_keywordContext.prototype.EACH = function() { + return this.getToken(PostgreSQLParser.EACH, 0); +}; + +Unreserved_keywordContext.prototype.ENABLE_P = function() { + return this.getToken(PostgreSQLParser.ENABLE_P, 0); +}; + +Unreserved_keywordContext.prototype.ENCODING = function() { + return this.getToken(PostgreSQLParser.ENCODING, 0); +}; + +Unreserved_keywordContext.prototype.ENCRYPTED = function() { + return this.getToken(PostgreSQLParser.ENCRYPTED, 0); +}; + +Unreserved_keywordContext.prototype.ENUM_P = function() { + return this.getToken(PostgreSQLParser.ENUM_P, 0); +}; + +Unreserved_keywordContext.prototype.ESCAPE = function() { + return this.getToken(PostgreSQLParser.ESCAPE, 0); +}; + +Unreserved_keywordContext.prototype.EVENT = function() { + return this.getToken(PostgreSQLParser.EVENT, 0); +}; + +Unreserved_keywordContext.prototype.EXCLUDE = function() { + return this.getToken(PostgreSQLParser.EXCLUDE, 0); +}; + +Unreserved_keywordContext.prototype.EXCLUDING = function() { + return this.getToken(PostgreSQLParser.EXCLUDING, 0); +}; + +Unreserved_keywordContext.prototype.EXCLUSIVE = function() { + return this.getToken(PostgreSQLParser.EXCLUSIVE, 0); +}; + +Unreserved_keywordContext.prototype.EXECUTE = function() { + return this.getToken(PostgreSQLParser.EXECUTE, 0); +}; + +Unreserved_keywordContext.prototype.EXPLAIN = function() { + return this.getToken(PostgreSQLParser.EXPLAIN, 0); +}; + +Unreserved_keywordContext.prototype.EXPRESSION = function() { + return this.getToken(PostgreSQLParser.EXPRESSION, 0); +}; + +Unreserved_keywordContext.prototype.EXTENSION = function() { + return this.getToken(PostgreSQLParser.EXTENSION, 0); +}; + +Unreserved_keywordContext.prototype.EXTERNAL = function() { + return this.getToken(PostgreSQLParser.EXTERNAL, 0); +}; + +Unreserved_keywordContext.prototype.FAMILY = function() { + return this.getToken(PostgreSQLParser.FAMILY, 0); +}; + +Unreserved_keywordContext.prototype.FILTER = function() { + return this.getToken(PostgreSQLParser.FILTER, 0); +}; + +Unreserved_keywordContext.prototype.FIRST_P = function() { + return this.getToken(PostgreSQLParser.FIRST_P, 0); +}; + +Unreserved_keywordContext.prototype.FOLLOWING = function() { + return this.getToken(PostgreSQLParser.FOLLOWING, 0); +}; + +Unreserved_keywordContext.prototype.FORCE = function() { + return this.getToken(PostgreSQLParser.FORCE, 0); +}; + +Unreserved_keywordContext.prototype.FORWARD = function() { + return this.getToken(PostgreSQLParser.FORWARD, 0); +}; + +Unreserved_keywordContext.prototype.FUNCTION = function() { + return this.getToken(PostgreSQLParser.FUNCTION, 0); +}; + +Unreserved_keywordContext.prototype.FUNCTIONS = function() { + return this.getToken(PostgreSQLParser.FUNCTIONS, 0); +}; + +Unreserved_keywordContext.prototype.GENERATED = function() { + return this.getToken(PostgreSQLParser.GENERATED, 0); +}; + +Unreserved_keywordContext.prototype.GLOBAL = function() { + return this.getToken(PostgreSQLParser.GLOBAL, 0); +}; + +Unreserved_keywordContext.prototype.GRANTED = function() { + return this.getToken(PostgreSQLParser.GRANTED, 0); +}; + +Unreserved_keywordContext.prototype.GROUPS = function() { + return this.getToken(PostgreSQLParser.GROUPS, 0); +}; + +Unreserved_keywordContext.prototype.HANDLER = function() { + return this.getToken(PostgreSQLParser.HANDLER, 0); +}; + +Unreserved_keywordContext.prototype.HEADER_P = function() { + return this.getToken(PostgreSQLParser.HEADER_P, 0); +}; + +Unreserved_keywordContext.prototype.HOLD = function() { + return this.getToken(PostgreSQLParser.HOLD, 0); +}; + +Unreserved_keywordContext.prototype.HOUR_P = function() { + return this.getToken(PostgreSQLParser.HOUR_P, 0); +}; + +Unreserved_keywordContext.prototype.IDENTITY_P = function() { + return this.getToken(PostgreSQLParser.IDENTITY_P, 0); +}; + +Unreserved_keywordContext.prototype.IF_P = function() { + return this.getToken(PostgreSQLParser.IF_P, 0); +}; + +Unreserved_keywordContext.prototype.IMMEDIATE = function() { + return this.getToken(PostgreSQLParser.IMMEDIATE, 0); +}; + +Unreserved_keywordContext.prototype.IMMUTABLE = function() { + return this.getToken(PostgreSQLParser.IMMUTABLE, 0); +}; + +Unreserved_keywordContext.prototype.IMPLICIT_P = function() { + return this.getToken(PostgreSQLParser.IMPLICIT_P, 0); +}; + +Unreserved_keywordContext.prototype.IMPORT_P = function() { + return this.getToken(PostgreSQLParser.IMPORT_P, 0); +}; + +Unreserved_keywordContext.prototype.INCLUDE = function() { + return this.getToken(PostgreSQLParser.INCLUDE, 0); +}; + +Unreserved_keywordContext.prototype.INCLUDING = function() { + return this.getToken(PostgreSQLParser.INCLUDING, 0); +}; + +Unreserved_keywordContext.prototype.INCREMENT = function() { + return this.getToken(PostgreSQLParser.INCREMENT, 0); +}; + +Unreserved_keywordContext.prototype.INDEX = function() { + return this.getToken(PostgreSQLParser.INDEX, 0); +}; + +Unreserved_keywordContext.prototype.INDEXES = function() { + return this.getToken(PostgreSQLParser.INDEXES, 0); +}; + +Unreserved_keywordContext.prototype.INHERIT = function() { + return this.getToken(PostgreSQLParser.INHERIT, 0); +}; + +Unreserved_keywordContext.prototype.INHERITS = function() { + return this.getToken(PostgreSQLParser.INHERITS, 0); +}; + +Unreserved_keywordContext.prototype.INLINE_P = function() { + return this.getToken(PostgreSQLParser.INLINE_P, 0); +}; + +Unreserved_keywordContext.prototype.INPUT_P = function() { + return this.getToken(PostgreSQLParser.INPUT_P, 0); +}; + +Unreserved_keywordContext.prototype.INSENSITIVE = function() { + return this.getToken(PostgreSQLParser.INSENSITIVE, 0); +}; + +Unreserved_keywordContext.prototype.INSERT = function() { + return this.getToken(PostgreSQLParser.INSERT, 0); +}; + +Unreserved_keywordContext.prototype.INSTEAD = function() { + return this.getToken(PostgreSQLParser.INSTEAD, 0); +}; + +Unreserved_keywordContext.prototype.INVOKER = function() { + return this.getToken(PostgreSQLParser.INVOKER, 0); +}; + +Unreserved_keywordContext.prototype.ISOLATION = function() { + return this.getToken(PostgreSQLParser.ISOLATION, 0); +}; + +Unreserved_keywordContext.prototype.KEY = function() { + return this.getToken(PostgreSQLParser.KEY, 0); +}; + +Unreserved_keywordContext.prototype.LABEL = function() { + return this.getToken(PostgreSQLParser.LABEL, 0); +}; + +Unreserved_keywordContext.prototype.LANGUAGE = function() { + return this.getToken(PostgreSQLParser.LANGUAGE, 0); +}; + +Unreserved_keywordContext.prototype.LARGE_P = function() { + return this.getToken(PostgreSQLParser.LARGE_P, 0); +}; + +Unreserved_keywordContext.prototype.LAST_P = function() { + return this.getToken(PostgreSQLParser.LAST_P, 0); +}; + +Unreserved_keywordContext.prototype.LEAKPROOF = function() { + return this.getToken(PostgreSQLParser.LEAKPROOF, 0); +}; + +Unreserved_keywordContext.prototype.LEVEL = function() { + return this.getToken(PostgreSQLParser.LEVEL, 0); +}; + +Unreserved_keywordContext.prototype.LISTEN = function() { + return this.getToken(PostgreSQLParser.LISTEN, 0); +}; + +Unreserved_keywordContext.prototype.LOAD = function() { + return this.getToken(PostgreSQLParser.LOAD, 0); +}; + +Unreserved_keywordContext.prototype.LOCAL = function() { + return this.getToken(PostgreSQLParser.LOCAL, 0); +}; + +Unreserved_keywordContext.prototype.LOCATION = function() { + return this.getToken(PostgreSQLParser.LOCATION, 0); +}; + +Unreserved_keywordContext.prototype.LOCK_P = function() { + return this.getToken(PostgreSQLParser.LOCK_P, 0); +}; + +Unreserved_keywordContext.prototype.LOCKED = function() { + return this.getToken(PostgreSQLParser.LOCKED, 0); +}; + +Unreserved_keywordContext.prototype.LOGGED = function() { + return this.getToken(PostgreSQLParser.LOGGED, 0); +}; + +Unreserved_keywordContext.prototype.MAPPING = function() { + return this.getToken(PostgreSQLParser.MAPPING, 0); +}; + +Unreserved_keywordContext.prototype.MATCH = function() { + return this.getToken(PostgreSQLParser.MATCH, 0); +}; + +Unreserved_keywordContext.prototype.MATERIALIZED = function() { + return this.getToken(PostgreSQLParser.MATERIALIZED, 0); +}; + +Unreserved_keywordContext.prototype.MAXVALUE = function() { + return this.getToken(PostgreSQLParser.MAXVALUE, 0); +}; + +Unreserved_keywordContext.prototype.METHOD = function() { + return this.getToken(PostgreSQLParser.METHOD, 0); +}; + +Unreserved_keywordContext.prototype.MINUTE_P = function() { + return this.getToken(PostgreSQLParser.MINUTE_P, 0); +}; + +Unreserved_keywordContext.prototype.MINVALUE = function() { + return this.getToken(PostgreSQLParser.MINVALUE, 0); +}; + +Unreserved_keywordContext.prototype.MODE = function() { + return this.getToken(PostgreSQLParser.MODE, 0); +}; + +Unreserved_keywordContext.prototype.MONTH_P = function() { + return this.getToken(PostgreSQLParser.MONTH_P, 0); +}; + +Unreserved_keywordContext.prototype.MOVE = function() { + return this.getToken(PostgreSQLParser.MOVE, 0); +}; + +Unreserved_keywordContext.prototype.NAME_P = function() { + return this.getToken(PostgreSQLParser.NAME_P, 0); +}; + +Unreserved_keywordContext.prototype.NAMES = function() { + return this.getToken(PostgreSQLParser.NAMES, 0); +}; + +Unreserved_keywordContext.prototype.NEW = function() { + return this.getToken(PostgreSQLParser.NEW, 0); +}; + +Unreserved_keywordContext.prototype.NEXT = function() { + return this.getToken(PostgreSQLParser.NEXT, 0); +}; + +Unreserved_keywordContext.prototype.NFC = function() { + return this.getToken(PostgreSQLParser.NFC, 0); +}; + +Unreserved_keywordContext.prototype.NFD = function() { + return this.getToken(PostgreSQLParser.NFD, 0); +}; + +Unreserved_keywordContext.prototype.NFKC = function() { + return this.getToken(PostgreSQLParser.NFKC, 0); +}; + +Unreserved_keywordContext.prototype.NFKD = function() { + return this.getToken(PostgreSQLParser.NFKD, 0); +}; + +Unreserved_keywordContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Unreserved_keywordContext.prototype.NORMALIZED = function() { + return this.getToken(PostgreSQLParser.NORMALIZED, 0); +}; + +Unreserved_keywordContext.prototype.NOTHING = function() { + return this.getToken(PostgreSQLParser.NOTHING, 0); +}; + +Unreserved_keywordContext.prototype.NOTIFY = function() { + return this.getToken(PostgreSQLParser.NOTIFY, 0); +}; + +Unreserved_keywordContext.prototype.NOWAIT = function() { + return this.getToken(PostgreSQLParser.NOWAIT, 0); +}; + +Unreserved_keywordContext.prototype.NULLS_P = function() { + return this.getToken(PostgreSQLParser.NULLS_P, 0); +}; + +Unreserved_keywordContext.prototype.OBJECT_P = function() { + return this.getToken(PostgreSQLParser.OBJECT_P, 0); +}; + +Unreserved_keywordContext.prototype.OF = function() { + return this.getToken(PostgreSQLParser.OF, 0); +}; + +Unreserved_keywordContext.prototype.OFF = function() { + return this.getToken(PostgreSQLParser.OFF, 0); +}; + +Unreserved_keywordContext.prototype.OIDS = function() { + return this.getToken(PostgreSQLParser.OIDS, 0); +}; + +Unreserved_keywordContext.prototype.OLD = function() { + return this.getToken(PostgreSQLParser.OLD, 0); +}; + +Unreserved_keywordContext.prototype.OPERATOR = function() { + return this.getToken(PostgreSQLParser.OPERATOR, 0); +}; + +Unreserved_keywordContext.prototype.OPTION = function() { + return this.getToken(PostgreSQLParser.OPTION, 0); +}; + +Unreserved_keywordContext.prototype.OPTIONS = function() { + return this.getToken(PostgreSQLParser.OPTIONS, 0); +}; + +Unreserved_keywordContext.prototype.ORDINALITY = function() { + return this.getToken(PostgreSQLParser.ORDINALITY, 0); +}; + +Unreserved_keywordContext.prototype.OTHERS = function() { + return this.getToken(PostgreSQLParser.OTHERS, 0); +}; + +Unreserved_keywordContext.prototype.OVER = function() { + return this.getToken(PostgreSQLParser.OVER, 0); +}; + +Unreserved_keywordContext.prototype.OVERRIDING = function() { + return this.getToken(PostgreSQLParser.OVERRIDING, 0); +}; + +Unreserved_keywordContext.prototype.OWNED = function() { + return this.getToken(PostgreSQLParser.OWNED, 0); +}; + +Unreserved_keywordContext.prototype.OWNER = function() { + return this.getToken(PostgreSQLParser.OWNER, 0); +}; + +Unreserved_keywordContext.prototype.PARALLEL = function() { + return this.getToken(PostgreSQLParser.PARALLEL, 0); +}; + +Unreserved_keywordContext.prototype.PARSER = function() { + return this.getToken(PostgreSQLParser.PARSER, 0); +}; + +Unreserved_keywordContext.prototype.PARTIAL = function() { + return this.getToken(PostgreSQLParser.PARTIAL, 0); +}; + +Unreserved_keywordContext.prototype.PARTITION = function() { + return this.getToken(PostgreSQLParser.PARTITION, 0); +}; + +Unreserved_keywordContext.prototype.PASSING = function() { + return this.getToken(PostgreSQLParser.PASSING, 0); +}; + +Unreserved_keywordContext.prototype.PASSWORD = function() { + return this.getToken(PostgreSQLParser.PASSWORD, 0); +}; + +Unreserved_keywordContext.prototype.PLANS = function() { + return this.getToken(PostgreSQLParser.PLANS, 0); +}; + +Unreserved_keywordContext.prototype.POLICY = function() { + return this.getToken(PostgreSQLParser.POLICY, 0); +}; + +Unreserved_keywordContext.prototype.PRECEDING = function() { + return this.getToken(PostgreSQLParser.PRECEDING, 0); +}; + +Unreserved_keywordContext.prototype.PREPARE = function() { + return this.getToken(PostgreSQLParser.PREPARE, 0); +}; + +Unreserved_keywordContext.prototype.PREPARED = function() { + return this.getToken(PostgreSQLParser.PREPARED, 0); +}; + +Unreserved_keywordContext.prototype.PRESERVE = function() { + return this.getToken(PostgreSQLParser.PRESERVE, 0); +}; + +Unreserved_keywordContext.prototype.PRIOR = function() { + return this.getToken(PostgreSQLParser.PRIOR, 0); +}; + +Unreserved_keywordContext.prototype.PRIVILEGES = function() { + return this.getToken(PostgreSQLParser.PRIVILEGES, 0); +}; + +Unreserved_keywordContext.prototype.PROCEDURAL = function() { + return this.getToken(PostgreSQLParser.PROCEDURAL, 0); +}; + +Unreserved_keywordContext.prototype.PROCEDURE = function() { + return this.getToken(PostgreSQLParser.PROCEDURE, 0); +}; + +Unreserved_keywordContext.prototype.PROCEDURES = function() { + return this.getToken(PostgreSQLParser.PROCEDURES, 0); +}; + +Unreserved_keywordContext.prototype.PROGRAM = function() { + return this.getToken(PostgreSQLParser.PROGRAM, 0); +}; + +Unreserved_keywordContext.prototype.PUBLICATION = function() { + return this.getToken(PostgreSQLParser.PUBLICATION, 0); +}; + +Unreserved_keywordContext.prototype.QUOTE = function() { + return this.getToken(PostgreSQLParser.QUOTE, 0); +}; + +Unreserved_keywordContext.prototype.RANGE = function() { + return this.getToken(PostgreSQLParser.RANGE, 0); +}; + +Unreserved_keywordContext.prototype.READ = function() { + return this.getToken(PostgreSQLParser.READ, 0); +}; + +Unreserved_keywordContext.prototype.REASSIGN = function() { + return this.getToken(PostgreSQLParser.REASSIGN, 0); +}; + +Unreserved_keywordContext.prototype.RECHECK = function() { + return this.getToken(PostgreSQLParser.RECHECK, 0); +}; + +Unreserved_keywordContext.prototype.RECURSIVE = function() { + return this.getToken(PostgreSQLParser.RECURSIVE, 0); +}; + +Unreserved_keywordContext.prototype.REF = function() { + return this.getToken(PostgreSQLParser.REF, 0); +}; + +Unreserved_keywordContext.prototype.REFERENCING = function() { + return this.getToken(PostgreSQLParser.REFERENCING, 0); +}; + +Unreserved_keywordContext.prototype.REFRESH = function() { + return this.getToken(PostgreSQLParser.REFRESH, 0); +}; + +Unreserved_keywordContext.prototype.REINDEX = function() { + return this.getToken(PostgreSQLParser.REINDEX, 0); +}; + +Unreserved_keywordContext.prototype.RELATIVE_P = function() { + return this.getToken(PostgreSQLParser.RELATIVE_P, 0); +}; + +Unreserved_keywordContext.prototype.RELEASE = function() { + return this.getToken(PostgreSQLParser.RELEASE, 0); +}; + +Unreserved_keywordContext.prototype.RENAME = function() { + return this.getToken(PostgreSQLParser.RENAME, 0); +}; + +Unreserved_keywordContext.prototype.REPEATABLE = function() { + return this.getToken(PostgreSQLParser.REPEATABLE, 0); +}; + +Unreserved_keywordContext.prototype.REPLACE = function() { + return this.getToken(PostgreSQLParser.REPLACE, 0); +}; + +Unreserved_keywordContext.prototype.REPLICA = function() { + return this.getToken(PostgreSQLParser.REPLICA, 0); +}; + +Unreserved_keywordContext.prototype.RESET = function() { + return this.getToken(PostgreSQLParser.RESET, 0); +}; + +Unreserved_keywordContext.prototype.RESTART = function() { + return this.getToken(PostgreSQLParser.RESTART, 0); +}; + +Unreserved_keywordContext.prototype.RESTRICT = function() { + return this.getToken(PostgreSQLParser.RESTRICT, 0); +}; + +Unreserved_keywordContext.prototype.RETURNS = function() { + return this.getToken(PostgreSQLParser.RETURNS, 0); +}; + +Unreserved_keywordContext.prototype.REVOKE = function() { + return this.getToken(PostgreSQLParser.REVOKE, 0); +}; + +Unreserved_keywordContext.prototype.ROLE = function() { + return this.getToken(PostgreSQLParser.ROLE, 0); +}; + +Unreserved_keywordContext.prototype.ROLLBACK = function() { + return this.getToken(PostgreSQLParser.ROLLBACK, 0); +}; + +Unreserved_keywordContext.prototype.ROLLUP = function() { + return this.getToken(PostgreSQLParser.ROLLUP, 0); +}; + +Unreserved_keywordContext.prototype.ROUTINE = function() { + return this.getToken(PostgreSQLParser.ROUTINE, 0); +}; + +Unreserved_keywordContext.prototype.ROUTINES = function() { + return this.getToken(PostgreSQLParser.ROUTINES, 0); +}; + +Unreserved_keywordContext.prototype.ROWS = function() { + return this.getToken(PostgreSQLParser.ROWS, 0); +}; + +Unreserved_keywordContext.prototype.RULE = function() { + return this.getToken(PostgreSQLParser.RULE, 0); +}; + +Unreserved_keywordContext.prototype.SAVEPOINT = function() { + return this.getToken(PostgreSQLParser.SAVEPOINT, 0); +}; + +Unreserved_keywordContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +Unreserved_keywordContext.prototype.SCHEMAS = function() { + return this.getToken(PostgreSQLParser.SCHEMAS, 0); +}; + +Unreserved_keywordContext.prototype.SCROLL = function() { + return this.getToken(PostgreSQLParser.SCROLL, 0); +}; + +Unreserved_keywordContext.prototype.SEARCH = function() { + return this.getToken(PostgreSQLParser.SEARCH, 0); +}; + +Unreserved_keywordContext.prototype.SECOND_P = function() { + return this.getToken(PostgreSQLParser.SECOND_P, 0); +}; + +Unreserved_keywordContext.prototype.SECURITY = function() { + return this.getToken(PostgreSQLParser.SECURITY, 0); +}; + +Unreserved_keywordContext.prototype.SEQUENCE = function() { + return this.getToken(PostgreSQLParser.SEQUENCE, 0); +}; + +Unreserved_keywordContext.prototype.SEQUENCES = function() { + return this.getToken(PostgreSQLParser.SEQUENCES, 0); +}; + +Unreserved_keywordContext.prototype.SERIALIZABLE = function() { + return this.getToken(PostgreSQLParser.SERIALIZABLE, 0); +}; + +Unreserved_keywordContext.prototype.SERVER = function() { + return this.getToken(PostgreSQLParser.SERVER, 0); +}; + +Unreserved_keywordContext.prototype.SESSION = function() { + return this.getToken(PostgreSQLParser.SESSION, 0); +}; + +Unreserved_keywordContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +Unreserved_keywordContext.prototype.SETS = function() { + return this.getToken(PostgreSQLParser.SETS, 0); +}; + +Unreserved_keywordContext.prototype.SHARE = function() { + return this.getToken(PostgreSQLParser.SHARE, 0); +}; + +Unreserved_keywordContext.prototype.SHOW = function() { + return this.getToken(PostgreSQLParser.SHOW, 0); +}; + +Unreserved_keywordContext.prototype.SIMPLE = function() { + return this.getToken(PostgreSQLParser.SIMPLE, 0); +}; + +Unreserved_keywordContext.prototype.SKIP_P = function() { + return this.getToken(PostgreSQLParser.SKIP_P, 0); +}; + +Unreserved_keywordContext.prototype.SNAPSHOT = function() { + return this.getToken(PostgreSQLParser.SNAPSHOT, 0); +}; + +Unreserved_keywordContext.prototype.SQL_P = function() { + return this.getToken(PostgreSQLParser.SQL_P, 0); +}; + +Unreserved_keywordContext.prototype.STABLE = function() { + return this.getToken(PostgreSQLParser.STABLE, 0); +}; + +Unreserved_keywordContext.prototype.STANDALONE_P = function() { + return this.getToken(PostgreSQLParser.STANDALONE_P, 0); +}; + +Unreserved_keywordContext.prototype.START = function() { + return this.getToken(PostgreSQLParser.START, 0); +}; + +Unreserved_keywordContext.prototype.STATEMENT = function() { + return this.getToken(PostgreSQLParser.STATEMENT, 0); +}; + +Unreserved_keywordContext.prototype.STATISTICS = function() { + return this.getToken(PostgreSQLParser.STATISTICS, 0); +}; + +Unreserved_keywordContext.prototype.STDIN = function() { + return this.getToken(PostgreSQLParser.STDIN, 0); +}; + +Unreserved_keywordContext.prototype.STDOUT = function() { + return this.getToken(PostgreSQLParser.STDOUT, 0); +}; + +Unreserved_keywordContext.prototype.STORAGE = function() { + return this.getToken(PostgreSQLParser.STORAGE, 0); +}; + +Unreserved_keywordContext.prototype.STORED = function() { + return this.getToken(PostgreSQLParser.STORED, 0); +}; + +Unreserved_keywordContext.prototype.STRICT_P = function() { + return this.getToken(PostgreSQLParser.STRICT_P, 0); +}; + +Unreserved_keywordContext.prototype.STRIP_P = function() { + return this.getToken(PostgreSQLParser.STRIP_P, 0); +}; + +Unreserved_keywordContext.prototype.SUBSCRIPTION = function() { + return this.getToken(PostgreSQLParser.SUBSCRIPTION, 0); +}; + +Unreserved_keywordContext.prototype.SUPPORT = function() { + return this.getToken(PostgreSQLParser.SUPPORT, 0); +}; + +Unreserved_keywordContext.prototype.SYSID = function() { + return this.getToken(PostgreSQLParser.SYSID, 0); +}; + +Unreserved_keywordContext.prototype.SYSTEM_P = function() { + return this.getToken(PostgreSQLParser.SYSTEM_P, 0); +}; + +Unreserved_keywordContext.prototype.TABLES = function() { + return this.getToken(PostgreSQLParser.TABLES, 0); +}; + +Unreserved_keywordContext.prototype.TABLESPACE = function() { + return this.getToken(PostgreSQLParser.TABLESPACE, 0); +}; + +Unreserved_keywordContext.prototype.TEMP = function() { + return this.getToken(PostgreSQLParser.TEMP, 0); +}; + +Unreserved_keywordContext.prototype.TEMPLATE = function() { + return this.getToken(PostgreSQLParser.TEMPLATE, 0); +}; + +Unreserved_keywordContext.prototype.TEMPORARY = function() { + return this.getToken(PostgreSQLParser.TEMPORARY, 0); +}; + +Unreserved_keywordContext.prototype.TEXT_P = function() { + return this.getToken(PostgreSQLParser.TEXT_P, 0); +}; + +Unreserved_keywordContext.prototype.TIES = function() { + return this.getToken(PostgreSQLParser.TIES, 0); +}; + +Unreserved_keywordContext.prototype.TRANSACTION = function() { + return this.getToken(PostgreSQLParser.TRANSACTION, 0); +}; + +Unreserved_keywordContext.prototype.TRANSFORM = function() { + return this.getToken(PostgreSQLParser.TRANSFORM, 0); +}; + +Unreserved_keywordContext.prototype.TRIGGER = function() { + return this.getToken(PostgreSQLParser.TRIGGER, 0); +}; + +Unreserved_keywordContext.prototype.TRUNCATE = function() { + return this.getToken(PostgreSQLParser.TRUNCATE, 0); +}; + +Unreserved_keywordContext.prototype.TRUSTED = function() { + return this.getToken(PostgreSQLParser.TRUSTED, 0); +}; + +Unreserved_keywordContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +Unreserved_keywordContext.prototype.TYPES_P = function() { + return this.getToken(PostgreSQLParser.TYPES_P, 0); +}; + +Unreserved_keywordContext.prototype.UESCAPE = function() { + return this.getToken(PostgreSQLParser.UESCAPE, 0); +}; + +Unreserved_keywordContext.prototype.UNBOUNDED = function() { + return this.getToken(PostgreSQLParser.UNBOUNDED, 0); +}; + +Unreserved_keywordContext.prototype.UNCOMMITTED = function() { + return this.getToken(PostgreSQLParser.UNCOMMITTED, 0); +}; + +Unreserved_keywordContext.prototype.UNENCRYPTED = function() { + return this.getToken(PostgreSQLParser.UNENCRYPTED, 0); +}; + +Unreserved_keywordContext.prototype.UNKNOWN = function() { + return this.getToken(PostgreSQLParser.UNKNOWN, 0); +}; + +Unreserved_keywordContext.prototype.UNLISTEN = function() { + return this.getToken(PostgreSQLParser.UNLISTEN, 0); +}; + +Unreserved_keywordContext.prototype.UNLOGGED = function() { + return this.getToken(PostgreSQLParser.UNLOGGED, 0); +}; + +Unreserved_keywordContext.prototype.UNTIL = function() { + return this.getToken(PostgreSQLParser.UNTIL, 0); +}; + +Unreserved_keywordContext.prototype.UPDATE = function() { + return this.getToken(PostgreSQLParser.UPDATE, 0); +}; + +Unreserved_keywordContext.prototype.VACUUM = function() { + return this.getToken(PostgreSQLParser.VACUUM, 0); +}; + +Unreserved_keywordContext.prototype.VALID = function() { + return this.getToken(PostgreSQLParser.VALID, 0); +}; + +Unreserved_keywordContext.prototype.VALIDATE = function() { + return this.getToken(PostgreSQLParser.VALIDATE, 0); +}; + +Unreserved_keywordContext.prototype.VALIDATOR = function() { + return this.getToken(PostgreSQLParser.VALIDATOR, 0); +}; + +Unreserved_keywordContext.prototype.VALUE_P = function() { + return this.getToken(PostgreSQLParser.VALUE_P, 0); +}; + +Unreserved_keywordContext.prototype.VARYING = function() { + return this.getToken(PostgreSQLParser.VARYING, 0); +}; + +Unreserved_keywordContext.prototype.VERSION_P = function() { + return this.getToken(PostgreSQLParser.VERSION_P, 0); +}; + +Unreserved_keywordContext.prototype.VIEW = function() { + return this.getToken(PostgreSQLParser.VIEW, 0); +}; + +Unreserved_keywordContext.prototype.VIEWS = function() { + return this.getToken(PostgreSQLParser.VIEWS, 0); +}; + +Unreserved_keywordContext.prototype.VOLATILE = function() { + return this.getToken(PostgreSQLParser.VOLATILE, 0); +}; + +Unreserved_keywordContext.prototype.WHITESPACE_P = function() { + return this.getToken(PostgreSQLParser.WHITESPACE_P, 0); +}; + +Unreserved_keywordContext.prototype.WITHIN = function() { + return this.getToken(PostgreSQLParser.WITHIN, 0); +}; + +Unreserved_keywordContext.prototype.WITHOUT = function() { + return this.getToken(PostgreSQLParser.WITHOUT, 0); +}; + +Unreserved_keywordContext.prototype.WORK = function() { + return this.getToken(PostgreSQLParser.WORK, 0); +}; + +Unreserved_keywordContext.prototype.WRAPPER = function() { + return this.getToken(PostgreSQLParser.WRAPPER, 0); +}; + +Unreserved_keywordContext.prototype.WRITE = function() { + return this.getToken(PostgreSQLParser.WRITE, 0); +}; + +Unreserved_keywordContext.prototype.XML_P = function() { + return this.getToken(PostgreSQLParser.XML_P, 0); +}; + +Unreserved_keywordContext.prototype.YEAR_P = function() { + return this.getToken(PostgreSQLParser.YEAR_P, 0); +}; + +Unreserved_keywordContext.prototype.YES_P = function() { + return this.getToken(PostgreSQLParser.YES_P, 0); +}; + +Unreserved_keywordContext.prototype.ZONE = function() { + return this.getToken(PostgreSQLParser.ZONE, 0); +}; + +Unreserved_keywordContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterUnreserved_keyword(this); + } +}; + +Unreserved_keywordContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitUnreserved_keyword(this); + } +}; + +Unreserved_keywordContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitUnreserved_keyword(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Unreserved_keywordContext = Unreserved_keywordContext; + +PostgreSQLParser.prototype.unreserved_keyword = function() { + + var localctx = new Unreserved_keywordContext(this, this._ctx, this.state); + this.enterRule(localctx, 1372, PostgreSQLParser.RULE_unreserved_keyword); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9759; + _la = this._input.LA(1); + if(!(((((_la - 124)) & ~0x1f) == 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.OVER - 124)) | (1 << (PostgreSQLParser.ABORT_P - 124)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 124)) | (1 << (PostgreSQLParser.ACCESS - 124)) | (1 << (PostgreSQLParser.ACTION - 124)) | (1 << (PostgreSQLParser.ADD_P - 124)) | (1 << (PostgreSQLParser.ADMIN - 124)) | (1 << (PostgreSQLParser.AFTER - 124)) | (1 << (PostgreSQLParser.AGGREGATE - 124)) | (1 << (PostgreSQLParser.ALSO - 124)) | (1 << (PostgreSQLParser.ALTER - 124)) | (1 << (PostgreSQLParser.ALWAYS - 124)) | (1 << (PostgreSQLParser.ASSERTION - 124)) | (1 << (PostgreSQLParser.ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.AT - 124)) | (1 << (PostgreSQLParser.ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.BACKWARD - 124)) | (1 << (PostgreSQLParser.BEFORE - 124)) | (1 << (PostgreSQLParser.BEGIN_P - 124)) | (1 << (PostgreSQLParser.BY - 124)) | (1 << (PostgreSQLParser.CACHE - 124)) | (1 << (PostgreSQLParser.CALLED - 124)) | (1 << (PostgreSQLParser.CASCADE - 124)) | (1 << (PostgreSQLParser.CASCADED - 124)) | (1 << (PostgreSQLParser.CATALOG - 124)) | (1 << (PostgreSQLParser.CHAIN - 124)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1f) == 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.CLASS - 156)) | (1 << (PostgreSQLParser.CLOSE - 156)) | (1 << (PostgreSQLParser.CLUSTER - 156)) | (1 << (PostgreSQLParser.COMMENT - 156)) | (1 << (PostgreSQLParser.COMMENTS - 156)) | (1 << (PostgreSQLParser.COMMIT - 156)) | (1 << (PostgreSQLParser.COMMITTED - 156)) | (1 << (PostgreSQLParser.CONFIGURATION - 156)) | (1 << (PostgreSQLParser.CONNECTION - 156)) | (1 << (PostgreSQLParser.CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.CONTENT_P - 156)) | (1 << (PostgreSQLParser.CONTINUE_P - 156)) | (1 << (PostgreSQLParser.CONVERSION_P - 156)) | (1 << (PostgreSQLParser.COPY - 156)) | (1 << (PostgreSQLParser.COST - 156)) | (1 << (PostgreSQLParser.CSV - 156)) | (1 << (PostgreSQLParser.CURSOR - 156)) | (1 << (PostgreSQLParser.CYCLE - 156)) | (1 << (PostgreSQLParser.DATA_P - 156)) | (1 << (PostgreSQLParser.DATABASE - 156)) | (1 << (PostgreSQLParser.DAY_P - 156)) | (1 << (PostgreSQLParser.DEALLOCATE - 156)) | (1 << (PostgreSQLParser.DECLARE - 156)) | (1 << (PostgreSQLParser.DEFAULTS - 156)) | (1 << (PostgreSQLParser.DEFERRED - 156)) | (1 << (PostgreSQLParser.DEFINER - 156)) | (1 << (PostgreSQLParser.DELETE_P - 156)) | (1 << (PostgreSQLParser.DELIMITER - 156)) | (1 << (PostgreSQLParser.DELIMITERS - 156)) | (1 << (PostgreSQLParser.DICTIONARY - 156)) | (1 << (PostgreSQLParser.DISABLE_P - 156)) | (1 << (PostgreSQLParser.DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1f) == 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.DOCUMENT_P - 188)) | (1 << (PostgreSQLParser.DOMAIN_P - 188)) | (1 << (PostgreSQLParser.DOUBLE_P - 188)) | (1 << (PostgreSQLParser.DROP - 188)) | (1 << (PostgreSQLParser.EACH - 188)) | (1 << (PostgreSQLParser.ENABLE_P - 188)) | (1 << (PostgreSQLParser.ENCODING - 188)) | (1 << (PostgreSQLParser.ENCRYPTED - 188)) | (1 << (PostgreSQLParser.ENUM_P - 188)) | (1 << (PostgreSQLParser.ESCAPE - 188)) | (1 << (PostgreSQLParser.EVENT - 188)) | (1 << (PostgreSQLParser.EXCLUDE - 188)) | (1 << (PostgreSQLParser.EXCLUDING - 188)) | (1 << (PostgreSQLParser.EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.EXECUTE - 188)) | (1 << (PostgreSQLParser.EXPLAIN - 188)) | (1 << (PostgreSQLParser.EXTENSION - 188)) | (1 << (PostgreSQLParser.EXTERNAL - 188)) | (1 << (PostgreSQLParser.FAMILY - 188)) | (1 << (PostgreSQLParser.FIRST_P - 188)) | (1 << (PostgreSQLParser.FOLLOWING - 188)) | (1 << (PostgreSQLParser.FORCE - 188)) | (1 << (PostgreSQLParser.FORWARD - 188)) | (1 << (PostgreSQLParser.FUNCTION - 188)) | (1 << (PostgreSQLParser.FUNCTIONS - 188)) | (1 << (PostgreSQLParser.GLOBAL - 188)) | (1 << (PostgreSQLParser.GRANTED - 188)) | (1 << (PostgreSQLParser.HANDLER - 188)) | (1 << (PostgreSQLParser.HEADER_P - 188)) | (1 << (PostgreSQLParser.HOLD - 188)) | (1 << (PostgreSQLParser.HOUR_P - 188)) | (1 << (PostgreSQLParser.IDENTITY_P - 188)))) !== 0) || ((((_la - 220)) & ~0x1f) == 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.IF_P - 220)) | (1 << (PostgreSQLParser.IMMEDIATE - 220)) | (1 << (PostgreSQLParser.IMMUTABLE - 220)) | (1 << (PostgreSQLParser.IMPLICIT_P - 220)) | (1 << (PostgreSQLParser.INCLUDING - 220)) | (1 << (PostgreSQLParser.INCREMENT - 220)) | (1 << (PostgreSQLParser.INDEX - 220)) | (1 << (PostgreSQLParser.INDEXES - 220)) | (1 << (PostgreSQLParser.INHERIT - 220)) | (1 << (PostgreSQLParser.INHERITS - 220)) | (1 << (PostgreSQLParser.INLINE_P - 220)) | (1 << (PostgreSQLParser.INSENSITIVE - 220)) | (1 << (PostgreSQLParser.INSERT - 220)) | (1 << (PostgreSQLParser.INSTEAD - 220)) | (1 << (PostgreSQLParser.INVOKER - 220)) | (1 << (PostgreSQLParser.ISOLATION - 220)) | (1 << (PostgreSQLParser.KEY - 220)) | (1 << (PostgreSQLParser.LABEL - 220)) | (1 << (PostgreSQLParser.LANGUAGE - 220)) | (1 << (PostgreSQLParser.LARGE_P - 220)) | (1 << (PostgreSQLParser.LAST_P - 220)) | (1 << (PostgreSQLParser.LEAKPROOF - 220)) | (1 << (PostgreSQLParser.LEVEL - 220)) | (1 << (PostgreSQLParser.LISTEN - 220)) | (1 << (PostgreSQLParser.LOAD - 220)) | (1 << (PostgreSQLParser.LOCAL - 220)) | (1 << (PostgreSQLParser.LOCATION - 220)) | (1 << (PostgreSQLParser.LOCK_P - 220)) | (1 << (PostgreSQLParser.MAPPING - 220)) | (1 << (PostgreSQLParser.MATCH - 220)) | (1 << (PostgreSQLParser.MATERIALIZED - 220)) | (1 << (PostgreSQLParser.MAXVALUE - 220)))) !== 0) || ((((_la - 252)) & ~0x1f) == 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.MINUTE_P - 252)) | (1 << (PostgreSQLParser.MINVALUE - 252)) | (1 << (PostgreSQLParser.MODE - 252)) | (1 << (PostgreSQLParser.MONTH_P - 252)) | (1 << (PostgreSQLParser.MOVE - 252)) | (1 << (PostgreSQLParser.NAME_P - 252)) | (1 << (PostgreSQLParser.NAMES - 252)) | (1 << (PostgreSQLParser.NEXT - 252)) | (1 << (PostgreSQLParser.NO - 252)) | (1 << (PostgreSQLParser.NOTHING - 252)) | (1 << (PostgreSQLParser.NOTIFY - 252)) | (1 << (PostgreSQLParser.NOWAIT - 252)) | (1 << (PostgreSQLParser.NULLS_P - 252)) | (1 << (PostgreSQLParser.OBJECT_P - 252)) | (1 << (PostgreSQLParser.OF - 252)) | (1 << (PostgreSQLParser.OFF - 252)) | (1 << (PostgreSQLParser.OIDS - 252)) | (1 << (PostgreSQLParser.OPERATOR - 252)) | (1 << (PostgreSQLParser.OPTION - 252)) | (1 << (PostgreSQLParser.OPTIONS - 252)) | (1 << (PostgreSQLParser.OWNED - 252)) | (1 << (PostgreSQLParser.OWNER - 252)) | (1 << (PostgreSQLParser.PARSER - 252)) | (1 << (PostgreSQLParser.PARTIAL - 252)) | (1 << (PostgreSQLParser.PARTITION - 252)) | (1 << (PostgreSQLParser.PASSING - 252)) | (1 << (PostgreSQLParser.PASSWORD - 252)) | (1 << (PostgreSQLParser.PLANS - 252)) | (1 << (PostgreSQLParser.PRECEDING - 252)) | (1 << (PostgreSQLParser.PREPARE - 252)) | (1 << (PostgreSQLParser.PREPARED - 252)) | (1 << (PostgreSQLParser.PRESERVE - 252)))) !== 0) || ((((_la - 284)) & ~0x1f) == 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.PRIOR - 284)) | (1 << (PostgreSQLParser.PRIVILEGES - 284)) | (1 << (PostgreSQLParser.PROCEDURAL - 284)) | (1 << (PostgreSQLParser.PROCEDURE - 284)) | (1 << (PostgreSQLParser.PROGRAM - 284)) | (1 << (PostgreSQLParser.QUOTE - 284)) | (1 << (PostgreSQLParser.RANGE - 284)) | (1 << (PostgreSQLParser.READ - 284)) | (1 << (PostgreSQLParser.REASSIGN - 284)) | (1 << (PostgreSQLParser.RECHECK - 284)) | (1 << (PostgreSQLParser.RECURSIVE - 284)) | (1 << (PostgreSQLParser.REF - 284)) | (1 << (PostgreSQLParser.REFRESH - 284)) | (1 << (PostgreSQLParser.REINDEX - 284)) | (1 << (PostgreSQLParser.RELATIVE_P - 284)) | (1 << (PostgreSQLParser.RELEASE - 284)) | (1 << (PostgreSQLParser.RENAME - 284)) | (1 << (PostgreSQLParser.REPEATABLE - 284)) | (1 << (PostgreSQLParser.REPLACE - 284)) | (1 << (PostgreSQLParser.REPLICA - 284)) | (1 << (PostgreSQLParser.RESET - 284)) | (1 << (PostgreSQLParser.RESTART - 284)) | (1 << (PostgreSQLParser.RESTRICT - 284)) | (1 << (PostgreSQLParser.RETURNS - 284)) | (1 << (PostgreSQLParser.REVOKE - 284)) | (1 << (PostgreSQLParser.ROLE - 284)) | (1 << (PostgreSQLParser.ROLLBACK - 284)) | (1 << (PostgreSQLParser.ROWS - 284)) | (1 << (PostgreSQLParser.RULE - 284)) | (1 << (PostgreSQLParser.SAVEPOINT - 284)) | (1 << (PostgreSQLParser.SCHEMA - 284)) | (1 << (PostgreSQLParser.SCROLL - 284)))) !== 0) || ((((_la - 316)) & ~0x1f) == 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.SEARCH - 316)) | (1 << (PostgreSQLParser.SECOND_P - 316)) | (1 << (PostgreSQLParser.SECURITY - 316)) | (1 << (PostgreSQLParser.SEQUENCE - 316)) | (1 << (PostgreSQLParser.SEQUENCES - 316)) | (1 << (PostgreSQLParser.SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.SERVER - 316)) | (1 << (PostgreSQLParser.SESSION - 316)) | (1 << (PostgreSQLParser.SET - 316)) | (1 << (PostgreSQLParser.SHARE - 316)) | (1 << (PostgreSQLParser.SHOW - 316)) | (1 << (PostgreSQLParser.SIMPLE - 316)) | (1 << (PostgreSQLParser.SNAPSHOT - 316)) | (1 << (PostgreSQLParser.STABLE - 316)) | (1 << (PostgreSQLParser.STANDALONE_P - 316)) | (1 << (PostgreSQLParser.START - 316)) | (1 << (PostgreSQLParser.STATEMENT - 316)) | (1 << (PostgreSQLParser.STATISTICS - 316)) | (1 << (PostgreSQLParser.STDIN - 316)) | (1 << (PostgreSQLParser.STDOUT - 316)) | (1 << (PostgreSQLParser.STORAGE - 316)) | (1 << (PostgreSQLParser.STRICT_P - 316)) | (1 << (PostgreSQLParser.STRIP_P - 316)) | (1 << (PostgreSQLParser.SYSID - 316)) | (1 << (PostgreSQLParser.SYSTEM_P - 316)) | (1 << (PostgreSQLParser.TABLES - 316)) | (1 << (PostgreSQLParser.TABLESPACE - 316)) | (1 << (PostgreSQLParser.TEMP - 316)) | (1 << (PostgreSQLParser.TEMPLATE - 316)) | (1 << (PostgreSQLParser.TEMPORARY - 316)) | (1 << (PostgreSQLParser.TEXT_P - 316)) | (1 << (PostgreSQLParser.TRANSACTION - 316)))) !== 0) || ((((_la - 348)) & ~0x1f) == 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.TRIGGER - 348)) | (1 << (PostgreSQLParser.TRUNCATE - 348)) | (1 << (PostgreSQLParser.TRUSTED - 348)) | (1 << (PostgreSQLParser.TYPE_P - 348)) | (1 << (PostgreSQLParser.TYPES_P - 348)) | (1 << (PostgreSQLParser.UNBOUNDED - 348)) | (1 << (PostgreSQLParser.UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.UNKNOWN - 348)) | (1 << (PostgreSQLParser.UNLISTEN - 348)) | (1 << (PostgreSQLParser.UNLOGGED - 348)) | (1 << (PostgreSQLParser.UNTIL - 348)) | (1 << (PostgreSQLParser.UPDATE - 348)) | (1 << (PostgreSQLParser.VACUUM - 348)) | (1 << (PostgreSQLParser.VALID - 348)) | (1 << (PostgreSQLParser.VALIDATE - 348)) | (1 << (PostgreSQLParser.VALIDATOR - 348)) | (1 << (PostgreSQLParser.VARYING - 348)) | (1 << (PostgreSQLParser.VERSION_P - 348)) | (1 << (PostgreSQLParser.VIEW - 348)) | (1 << (PostgreSQLParser.VOLATILE - 348)) | (1 << (PostgreSQLParser.WHITESPACE_P - 348)) | (1 << (PostgreSQLParser.WITHOUT - 348)) | (1 << (PostgreSQLParser.WORK - 348)) | (1 << (PostgreSQLParser.WRAPPER - 348)) | (1 << (PostgreSQLParser.WRITE - 348)) | (1 << (PostgreSQLParser.XML_P - 348)) | (1 << (PostgreSQLParser.YEAR_P - 348)) | (1 << (PostgreSQLParser.YES_P - 348)) | (1 << (PostgreSQLParser.ZONE - 348)))) !== 0) || ((((_la - 424)) & ~0x1f) == 0 && ((1 << (_la - 424)) & ((1 << (PostgreSQLParser.CALL - 424)) | (1 << (PostgreSQLParser.CURRENT_P - 424)) | (1 << (PostgreSQLParser.ATTACH - 424)) | (1 << (PostgreSQLParser.DETACH - 424)) | (1 << (PostgreSQLParser.EXPRESSION - 424)) | (1 << (PostgreSQLParser.GENERATED - 424)) | (1 << (PostgreSQLParser.LOGGED - 424)) | (1 << (PostgreSQLParser.STORED - 424)) | (1 << (PostgreSQLParser.INCLUDE - 424)) | (1 << (PostgreSQLParser.ROUTINE - 424)) | (1 << (PostgreSQLParser.TRANSFORM - 424)) | (1 << (PostgreSQLParser.IMPORT_P - 424)) | (1 << (PostgreSQLParser.POLICY - 424)) | (1 << (PostgreSQLParser.METHOD - 424)) | (1 << (PostgreSQLParser.REFERENCING - 424)) | (1 << (PostgreSQLParser.NEW - 424)) | (1 << (PostgreSQLParser.OLD - 424)) | (1 << (PostgreSQLParser.VALUE_P - 424)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 424)) | (1 << (PostgreSQLParser.PUBLICATION - 424)) | (1 << (PostgreSQLParser.ROUTINES - 424)) | (1 << (PostgreSQLParser.SCHEMAS - 424)) | (1 << (PostgreSQLParser.PROCEDURES - 424)) | (1 << (PostgreSQLParser.INPUT_P - 424)) | (1 << (PostgreSQLParser.SUPPORT - 424)) | (1 << (PostgreSQLParser.PARALLEL - 424)) | (1 << (PostgreSQLParser.SQL_P - 424)) | (1 << (PostgreSQLParser.DEPENDS - 424)) | (1 << (PostgreSQLParser.OVERRIDING - 424)) | (1 << (PostgreSQLParser.CONFLICT - 424)))) !== 0) || ((((_la - 456)) & ~0x1f) == 0 && ((1 << (_la - 456)) & ((1 << (PostgreSQLParser.SKIP_P - 456)) | (1 << (PostgreSQLParser.LOCKED - 456)) | (1 << (PostgreSQLParser.TIES - 456)) | (1 << (PostgreSQLParser.ROLLUP - 456)) | (1 << (PostgreSQLParser.CUBE - 456)) | (1 << (PostgreSQLParser.SETS - 456)) | (1 << (PostgreSQLParser.ORDINALITY - 456)) | (1 << (PostgreSQLParser.COLUMNS - 456)) | (1 << (PostgreSQLParser.NORMALIZED - 456)) | (1 << (PostgreSQLParser.WITHIN - 456)) | (1 << (PostgreSQLParser.FILTER - 456)) | (1 << (PostgreSQLParser.GROUPS - 456)) | (1 << (PostgreSQLParser.OTHERS - 456)) | (1 << (PostgreSQLParser.NFC - 456)) | (1 << (PostgreSQLParser.NFD - 456)) | (1 << (PostgreSQLParser.NFKC - 456)) | (1 << (PostgreSQLParser.NFKD - 456)) | (1 << (PostgreSQLParser.UESCAPE - 456)) | (1 << (PostgreSQLParser.VIEWS - 456)))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Col_name_keywordContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_col_name_keyword; + return this; +} + +Col_name_keywordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Col_name_keywordContext.prototype.constructor = Col_name_keywordContext; + +Col_name_keywordContext.prototype.BETWEEN = function() { + return this.getToken(PostgreSQLParser.BETWEEN, 0); +}; + +Col_name_keywordContext.prototype.BIGINT = function() { + return this.getToken(PostgreSQLParser.BIGINT, 0); +}; + +Col_name_keywordContext.prototype.bit = function() { + return this.getTypedRuleContext(BitContext,0); +}; + +Col_name_keywordContext.prototype.BOOLEAN_P = function() { + return this.getToken(PostgreSQLParser.BOOLEAN_P, 0); +}; + +Col_name_keywordContext.prototype.CHAR_P = function() { + return this.getToken(PostgreSQLParser.CHAR_P, 0); +}; + +Col_name_keywordContext.prototype.character = function() { + return this.getTypedRuleContext(CharacterContext,0); +}; + +Col_name_keywordContext.prototype.COALESCE = function() { + return this.getToken(PostgreSQLParser.COALESCE, 0); +}; + +Col_name_keywordContext.prototype.DEC = function() { + return this.getToken(PostgreSQLParser.DEC, 0); +}; + +Col_name_keywordContext.prototype.DECIMAL_P = function() { + return this.getToken(PostgreSQLParser.DECIMAL_P, 0); +}; + +Col_name_keywordContext.prototype.EXISTS = function() { + return this.getToken(PostgreSQLParser.EXISTS, 0); +}; + +Col_name_keywordContext.prototype.EXTRACT = function() { + return this.getToken(PostgreSQLParser.EXTRACT, 0); +}; + +Col_name_keywordContext.prototype.FLOAT_P = function() { + return this.getToken(PostgreSQLParser.FLOAT_P, 0); +}; + +Col_name_keywordContext.prototype.GREATEST = function() { + return this.getToken(PostgreSQLParser.GREATEST, 0); +}; + +Col_name_keywordContext.prototype.GROUPING = function() { + return this.getToken(PostgreSQLParser.GROUPING, 0); +}; + +Col_name_keywordContext.prototype.INOUT = function() { + return this.getToken(PostgreSQLParser.INOUT, 0); +}; + +Col_name_keywordContext.prototype.INT_P = function() { + return this.getToken(PostgreSQLParser.INT_P, 0); +}; + +Col_name_keywordContext.prototype.INTEGER = function() { + return this.getToken(PostgreSQLParser.INTEGER, 0); +}; + +Col_name_keywordContext.prototype.INTERVAL = function() { + return this.getToken(PostgreSQLParser.INTERVAL, 0); +}; + +Col_name_keywordContext.prototype.LEAST = function() { + return this.getToken(PostgreSQLParser.LEAST, 0); +}; + +Col_name_keywordContext.prototype.NATIONAL = function() { + return this.getToken(PostgreSQLParser.NATIONAL, 0); +}; + +Col_name_keywordContext.prototype.NCHAR = function() { + return this.getToken(PostgreSQLParser.NCHAR, 0); +}; + +Col_name_keywordContext.prototype.NONE = function() { + return this.getToken(PostgreSQLParser.NONE, 0); +}; + +Col_name_keywordContext.prototype.NORMALIZE = function() { + return this.getToken(PostgreSQLParser.NORMALIZE, 0); +}; + +Col_name_keywordContext.prototype.NULLIF = function() { + return this.getToken(PostgreSQLParser.NULLIF, 0); +}; + +Col_name_keywordContext.prototype.numeric = function() { + return this.getTypedRuleContext(NumericContext,0); +}; + +Col_name_keywordContext.prototype.OUT_P = function() { + return this.getToken(PostgreSQLParser.OUT_P, 0); +}; + +Col_name_keywordContext.prototype.OVERLAY = function() { + return this.getToken(PostgreSQLParser.OVERLAY, 0); +}; + +Col_name_keywordContext.prototype.POSITION = function() { + return this.getToken(PostgreSQLParser.POSITION, 0); +}; + +Col_name_keywordContext.prototype.PRECISION = function() { + return this.getToken(PostgreSQLParser.PRECISION, 0); +}; + +Col_name_keywordContext.prototype.REAL = function() { + return this.getToken(PostgreSQLParser.REAL, 0); +}; + +Col_name_keywordContext.prototype.ROW = function() { + return this.getToken(PostgreSQLParser.ROW, 0); +}; + +Col_name_keywordContext.prototype.SETOF = function() { + return this.getToken(PostgreSQLParser.SETOF, 0); +}; + +Col_name_keywordContext.prototype.SMALLINT = function() { + return this.getToken(PostgreSQLParser.SMALLINT, 0); +}; + +Col_name_keywordContext.prototype.SUBSTRING = function() { + return this.getToken(PostgreSQLParser.SUBSTRING, 0); +}; + +Col_name_keywordContext.prototype.TIME = function() { + return this.getToken(PostgreSQLParser.TIME, 0); +}; + +Col_name_keywordContext.prototype.TIMESTAMP = function() { + return this.getToken(PostgreSQLParser.TIMESTAMP, 0); +}; + +Col_name_keywordContext.prototype.TREAT = function() { + return this.getToken(PostgreSQLParser.TREAT, 0); +}; + +Col_name_keywordContext.prototype.TRIM = function() { + return this.getToken(PostgreSQLParser.TRIM, 0); +}; + +Col_name_keywordContext.prototype.VALUES = function() { + return this.getToken(PostgreSQLParser.VALUES, 0); +}; + +Col_name_keywordContext.prototype.VARCHAR = function() { + return this.getToken(PostgreSQLParser.VARCHAR, 0); +}; + +Col_name_keywordContext.prototype.XMLATTRIBUTES = function() { + return this.getToken(PostgreSQLParser.XMLATTRIBUTES, 0); +}; + +Col_name_keywordContext.prototype.XMLCONCAT = function() { + return this.getToken(PostgreSQLParser.XMLCONCAT, 0); +}; + +Col_name_keywordContext.prototype.XMLELEMENT = function() { + return this.getToken(PostgreSQLParser.XMLELEMENT, 0); +}; + +Col_name_keywordContext.prototype.XMLEXISTS = function() { + return this.getToken(PostgreSQLParser.XMLEXISTS, 0); +}; + +Col_name_keywordContext.prototype.XMLFOREST = function() { + return this.getToken(PostgreSQLParser.XMLFOREST, 0); +}; + +Col_name_keywordContext.prototype.XMLNAMESPACES = function() { + return this.getToken(PostgreSQLParser.XMLNAMESPACES, 0); +}; + +Col_name_keywordContext.prototype.XMLPARSE = function() { + return this.getToken(PostgreSQLParser.XMLPARSE, 0); +}; + +Col_name_keywordContext.prototype.XMLPI = function() { + return this.getToken(PostgreSQLParser.XMLPI, 0); +}; + +Col_name_keywordContext.prototype.XMLROOT = function() { + return this.getToken(PostgreSQLParser.XMLROOT, 0); +}; + +Col_name_keywordContext.prototype.XMLSERIALIZE = function() { + return this.getToken(PostgreSQLParser.XMLSERIALIZE, 0); +}; + +Col_name_keywordContext.prototype.XMLTABLE = function() { + return this.getToken(PostgreSQLParser.XMLTABLE, 0); +}; + +Col_name_keywordContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCol_name_keyword(this); + } +}; + +Col_name_keywordContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCol_name_keyword(this); + } +}; + +Col_name_keywordContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCol_name_keyword(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Col_name_keywordContext = Col_name_keywordContext; + +PostgreSQLParser.prototype.col_name_keyword = function() { + + var localctx = new Col_name_keywordContext(this, this._ctx, this.state); + this.enterRule(localctx, 1374, PostgreSQLParser.RULE_col_name_keyword); + try { + this.state = 9812; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,642,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9761; + this.match(PostgreSQLParser.BETWEEN); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9762; + this.match(PostgreSQLParser.BIGINT); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9763; + this.bit(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9764; + this.match(PostgreSQLParser.BOOLEAN_P); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 9765; + this.match(PostgreSQLParser.CHAR_P); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 9766; + this.character(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 9767; + this.match(PostgreSQLParser.COALESCE); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 9768; + this.match(PostgreSQLParser.DEC); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 9769; + this.match(PostgreSQLParser.DECIMAL_P); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 9770; + this.match(PostgreSQLParser.EXISTS); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 9771; + this.match(PostgreSQLParser.EXTRACT); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 9772; + this.match(PostgreSQLParser.FLOAT_P); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 9773; + this.match(PostgreSQLParser.GREATEST); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 9774; + this.match(PostgreSQLParser.GROUPING); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 9775; + this.match(PostgreSQLParser.INOUT); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 9776; + this.match(PostgreSQLParser.INT_P); + break; + + case 17: + this.enterOuterAlt(localctx, 17); + this.state = 9777; + this.match(PostgreSQLParser.INTEGER); + break; + + case 18: + this.enterOuterAlt(localctx, 18); + this.state = 9778; + this.match(PostgreSQLParser.INTERVAL); + break; + + case 19: + this.enterOuterAlt(localctx, 19); + this.state = 9779; + this.match(PostgreSQLParser.LEAST); + break; + + case 20: + this.enterOuterAlt(localctx, 20); + this.state = 9780; + this.match(PostgreSQLParser.NATIONAL); + break; + + case 21: + this.enterOuterAlt(localctx, 21); + this.state = 9781; + this.match(PostgreSQLParser.NCHAR); + break; + + case 22: + this.enterOuterAlt(localctx, 22); + this.state = 9782; + this.match(PostgreSQLParser.NONE); + break; + + case 23: + this.enterOuterAlt(localctx, 23); + this.state = 9783; + this.match(PostgreSQLParser.NORMALIZE); + break; + + case 24: + this.enterOuterAlt(localctx, 24); + this.state = 9784; + this.match(PostgreSQLParser.NULLIF); + break; + + case 25: + this.enterOuterAlt(localctx, 25); + this.state = 9785; + this.numeric(); + break; + + case 26: + this.enterOuterAlt(localctx, 26); + this.state = 9786; + this.match(PostgreSQLParser.OUT_P); + break; + + case 27: + this.enterOuterAlt(localctx, 27); + this.state = 9787; + this.match(PostgreSQLParser.OVERLAY); + break; + + case 28: + this.enterOuterAlt(localctx, 28); + this.state = 9788; + this.match(PostgreSQLParser.POSITION); + break; + + case 29: + this.enterOuterAlt(localctx, 29); + this.state = 9789; + this.match(PostgreSQLParser.PRECISION); + break; + + case 30: + this.enterOuterAlt(localctx, 30); + this.state = 9790; + this.match(PostgreSQLParser.REAL); + break; + + case 31: + this.enterOuterAlt(localctx, 31); + this.state = 9791; + this.match(PostgreSQLParser.ROW); + break; + + case 32: + this.enterOuterAlt(localctx, 32); + this.state = 9792; + this.match(PostgreSQLParser.SETOF); + break; + + case 33: + this.enterOuterAlt(localctx, 33); + this.state = 9793; + this.match(PostgreSQLParser.SMALLINT); + break; + + case 34: + this.enterOuterAlt(localctx, 34); + this.state = 9794; + this.match(PostgreSQLParser.SUBSTRING); + break; + + case 35: + this.enterOuterAlt(localctx, 35); + this.state = 9795; + this.match(PostgreSQLParser.TIME); + break; + + case 36: + this.enterOuterAlt(localctx, 36); + this.state = 9796; + this.match(PostgreSQLParser.TIMESTAMP); + break; + + case 37: + this.enterOuterAlt(localctx, 37); + this.state = 9797; + this.match(PostgreSQLParser.TREAT); + break; + + case 38: + this.enterOuterAlt(localctx, 38); + this.state = 9798; + this.match(PostgreSQLParser.TRIM); + break; + + case 39: + this.enterOuterAlt(localctx, 39); + this.state = 9799; + this.match(PostgreSQLParser.VALUES); + break; + + case 40: + this.enterOuterAlt(localctx, 40); + this.state = 9800; + this.match(PostgreSQLParser.VARCHAR); + break; + + case 41: + this.enterOuterAlt(localctx, 41); + this.state = 9801; + this.match(PostgreSQLParser.XMLATTRIBUTES); + break; + + case 42: + this.enterOuterAlt(localctx, 42); + this.state = 9802; + this.match(PostgreSQLParser.XMLCONCAT); + break; + + case 43: + this.enterOuterAlt(localctx, 43); + this.state = 9803; + this.match(PostgreSQLParser.XMLELEMENT); + break; + + case 44: + this.enterOuterAlt(localctx, 44); + this.state = 9804; + this.match(PostgreSQLParser.XMLEXISTS); + break; + + case 45: + this.enterOuterAlt(localctx, 45); + this.state = 9805; + this.match(PostgreSQLParser.XMLFOREST); + break; + + case 46: + this.enterOuterAlt(localctx, 46); + this.state = 9806; + this.match(PostgreSQLParser.XMLNAMESPACES); + break; + + case 47: + this.enterOuterAlt(localctx, 47); + this.state = 9807; + this.match(PostgreSQLParser.XMLPARSE); + break; + + case 48: + this.enterOuterAlt(localctx, 48); + this.state = 9808; + this.match(PostgreSQLParser.XMLPI); + break; + + case 49: + this.enterOuterAlt(localctx, 49); + this.state = 9809; + this.match(PostgreSQLParser.XMLROOT); + break; + + case 50: + this.enterOuterAlt(localctx, 50); + this.state = 9810; + this.match(PostgreSQLParser.XMLSERIALIZE); + break; + + case 51: + this.enterOuterAlt(localctx, 51); + this.state = 9811; + this.match(PostgreSQLParser.XMLTABLE); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Type_func_name_keywordContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_type_func_name_keyword; + return this; +} + +Type_func_name_keywordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Type_func_name_keywordContext.prototype.constructor = Type_func_name_keywordContext; + +Type_func_name_keywordContext.prototype.AUTHORIZATION = function() { + return this.getToken(PostgreSQLParser.AUTHORIZATION, 0); +}; + +Type_func_name_keywordContext.prototype.BINARY = function() { + return this.getToken(PostgreSQLParser.BINARY, 0); +}; + +Type_func_name_keywordContext.prototype.COLLATION = function() { + return this.getToken(PostgreSQLParser.COLLATION, 0); +}; + +Type_func_name_keywordContext.prototype.CONCURRENTLY = function() { + return this.getToken(PostgreSQLParser.CONCURRENTLY, 0); +}; + +Type_func_name_keywordContext.prototype.CROSS = function() { + return this.getToken(PostgreSQLParser.CROSS, 0); +}; + +Type_func_name_keywordContext.prototype.CURRENT_SCHEMA = function() { + return this.getToken(PostgreSQLParser.CURRENT_SCHEMA, 0); +}; + +Type_func_name_keywordContext.prototype.FREEZE = function() { + return this.getToken(PostgreSQLParser.FREEZE, 0); +}; + +Type_func_name_keywordContext.prototype.FULL = function() { + return this.getToken(PostgreSQLParser.FULL, 0); +}; + +Type_func_name_keywordContext.prototype.ILIKE = function() { + return this.getToken(PostgreSQLParser.ILIKE, 0); +}; + +Type_func_name_keywordContext.prototype.INNER_P = function() { + return this.getToken(PostgreSQLParser.INNER_P, 0); +}; + +Type_func_name_keywordContext.prototype.IS = function() { + return this.getToken(PostgreSQLParser.IS, 0); +}; + +Type_func_name_keywordContext.prototype.ISNULL = function() { + return this.getToken(PostgreSQLParser.ISNULL, 0); +}; + +Type_func_name_keywordContext.prototype.JOIN = function() { + return this.getToken(PostgreSQLParser.JOIN, 0); +}; + +Type_func_name_keywordContext.prototype.LEFT = function() { + return this.getToken(PostgreSQLParser.LEFT, 0); +}; + +Type_func_name_keywordContext.prototype.LIKE = function() { + return this.getToken(PostgreSQLParser.LIKE, 0); +}; + +Type_func_name_keywordContext.prototype.NATURAL = function() { + return this.getToken(PostgreSQLParser.NATURAL, 0); +}; + +Type_func_name_keywordContext.prototype.NOTNULL = function() { + return this.getToken(PostgreSQLParser.NOTNULL, 0); +}; + +Type_func_name_keywordContext.prototype.OUTER_P = function() { + return this.getToken(PostgreSQLParser.OUTER_P, 0); +}; + +Type_func_name_keywordContext.prototype.OVERLAPS = function() { + return this.getToken(PostgreSQLParser.OVERLAPS, 0); +}; + +Type_func_name_keywordContext.prototype.RIGHT = function() { + return this.getToken(PostgreSQLParser.RIGHT, 0); +}; + +Type_func_name_keywordContext.prototype.SIMILAR = function() { + return this.getToken(PostgreSQLParser.SIMILAR, 0); +}; + +Type_func_name_keywordContext.prototype.TABLESAMPLE = function() { + return this.getToken(PostgreSQLParser.TABLESAMPLE, 0); +}; + +Type_func_name_keywordContext.prototype.VERBOSE = function() { + return this.getToken(PostgreSQLParser.VERBOSE, 0); +}; + +Type_func_name_keywordContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterType_func_name_keyword(this); + } +}; + +Type_func_name_keywordContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitType_func_name_keyword(this); + } +}; + +Type_func_name_keywordContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitType_func_name_keyword(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Type_func_name_keywordContext = Type_func_name_keywordContext; + +PostgreSQLParser.prototype.type_func_name_keyword = function() { + + var localctx = new Type_func_name_keywordContext(this, this._ctx, this.state); + this.enterRule(localctx, 1376, PostgreSQLParser.RULE_type_func_name_keyword); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9814; + _la = this._input.LA(1); + if(!(((((_la - 106)) & ~0x1f) == 0 && ((1 << (_la - 106)) & ((1 << (PostgreSQLParser.AUTHORIZATION - 106)) | (1 << (PostgreSQLParser.BINARY - 106)) | (1 << (PostgreSQLParser.COLLATION - 106)) | (1 << (PostgreSQLParser.CONCURRENTLY - 106)) | (1 << (PostgreSQLParser.CROSS - 106)) | (1 << (PostgreSQLParser.CURRENT_SCHEMA - 106)) | (1 << (PostgreSQLParser.FREEZE - 106)) | (1 << (PostgreSQLParser.FULL - 106)) | (1 << (PostgreSQLParser.ILIKE - 106)) | (1 << (PostgreSQLParser.INNER_P - 106)) | (1 << (PostgreSQLParser.IS - 106)) | (1 << (PostgreSQLParser.ISNULL - 106)) | (1 << (PostgreSQLParser.JOIN - 106)) | (1 << (PostgreSQLParser.LEFT - 106)) | (1 << (PostgreSQLParser.LIKE - 106)) | (1 << (PostgreSQLParser.NATURAL - 106)) | (1 << (PostgreSQLParser.NOTNULL - 106)) | (1 << (PostgreSQLParser.OUTER_P - 106)) | (1 << (PostgreSQLParser.OVERLAPS - 106)) | (1 << (PostgreSQLParser.RIGHT - 106)) | (1 << (PostgreSQLParser.SIMILAR - 106)) | (1 << (PostgreSQLParser.VERBOSE - 106)))) !== 0) || _la===PostgreSQLParser.TABLESAMPLE)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Reserved_keywordContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_reserved_keyword; + return this; +} + +Reserved_keywordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Reserved_keywordContext.prototype.constructor = Reserved_keywordContext; + +Reserved_keywordContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Reserved_keywordContext.prototype.ANALYSE = function() { + return this.getToken(PostgreSQLParser.ANALYSE, 0); +}; + +Reserved_keywordContext.prototype.ANALYZE = function() { + return this.getToken(PostgreSQLParser.ANALYZE, 0); +}; + +Reserved_keywordContext.prototype.AND = function() { + return this.getToken(PostgreSQLParser.AND, 0); +}; + +Reserved_keywordContext.prototype.ANY = function() { + return this.getToken(PostgreSQLParser.ANY, 0); +}; + +Reserved_keywordContext.prototype.ARRAY = function() { + return this.getToken(PostgreSQLParser.ARRAY, 0); +}; + +Reserved_keywordContext.prototype.AS = function() { + return this.getToken(PostgreSQLParser.AS, 0); +}; + +Reserved_keywordContext.prototype.ASC = function() { + return this.getToken(PostgreSQLParser.ASC, 0); +}; + +Reserved_keywordContext.prototype.ASYMMETRIC = function() { + return this.getToken(PostgreSQLParser.ASYMMETRIC, 0); +}; + +Reserved_keywordContext.prototype.BOTH = function() { + return this.getToken(PostgreSQLParser.BOTH, 0); +}; + +Reserved_keywordContext.prototype.CASE = function() { + return this.getToken(PostgreSQLParser.CASE, 0); +}; + +Reserved_keywordContext.prototype.CAST = function() { + return this.getToken(PostgreSQLParser.CAST, 0); +}; + +Reserved_keywordContext.prototype.CHECK = function() { + return this.getToken(PostgreSQLParser.CHECK, 0); +}; + +Reserved_keywordContext.prototype.COLLATE = function() { + return this.getToken(PostgreSQLParser.COLLATE, 0); +}; + +Reserved_keywordContext.prototype.COLUMN = function() { + return this.getToken(PostgreSQLParser.COLUMN, 0); +}; + +Reserved_keywordContext.prototype.CONSTRAINT = function() { + return this.getToken(PostgreSQLParser.CONSTRAINT, 0); +}; + +Reserved_keywordContext.prototype.CREATE = function() { + return this.getToken(PostgreSQLParser.CREATE, 0); +}; + +Reserved_keywordContext.prototype.CURRENT_CATALOG = function() { + return this.getToken(PostgreSQLParser.CURRENT_CATALOG, 0); +}; + +Reserved_keywordContext.prototype.CURRENT_DATE = function() { + return this.getToken(PostgreSQLParser.CURRENT_DATE, 0); +}; + +Reserved_keywordContext.prototype.CURRENT_ROLE = function() { + return this.getToken(PostgreSQLParser.CURRENT_ROLE, 0); +}; + +Reserved_keywordContext.prototype.CURRENT_TIME = function() { + return this.getToken(PostgreSQLParser.CURRENT_TIME, 0); +}; + +Reserved_keywordContext.prototype.CURRENT_TIMESTAMP = function() { + return this.getToken(PostgreSQLParser.CURRENT_TIMESTAMP, 0); +}; + +Reserved_keywordContext.prototype.CURRENT_USER = function() { + return this.getToken(PostgreSQLParser.CURRENT_USER, 0); +}; + +Reserved_keywordContext.prototype.DEFERRABLE = function() { + return this.getToken(PostgreSQLParser.DEFERRABLE, 0); +}; + +Reserved_keywordContext.prototype.DESC = function() { + return this.getToken(PostgreSQLParser.DESC, 0); +}; + +Reserved_keywordContext.prototype.DISTINCT = function() { + return this.getToken(PostgreSQLParser.DISTINCT, 0); +}; + +Reserved_keywordContext.prototype.DO = function() { + return this.getToken(PostgreSQLParser.DO, 0); +}; + +Reserved_keywordContext.prototype.ELSE = function() { + return this.getToken(PostgreSQLParser.ELSE, 0); +}; + +Reserved_keywordContext.prototype.END_P = function() { + return this.getToken(PostgreSQLParser.END_P, 0); +}; + +Reserved_keywordContext.prototype.EXCEPT = function() { + return this.getToken(PostgreSQLParser.EXCEPT, 0); +}; + +Reserved_keywordContext.prototype.FALSE_P = function() { + return this.getToken(PostgreSQLParser.FALSE_P, 0); +}; + +Reserved_keywordContext.prototype.FETCH = function() { + return this.getToken(PostgreSQLParser.FETCH, 0); +}; + +Reserved_keywordContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Reserved_keywordContext.prototype.FOREIGN = function() { + return this.getToken(PostgreSQLParser.FOREIGN, 0); +}; + +Reserved_keywordContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Reserved_keywordContext.prototype.GRANT = function() { + return this.getToken(PostgreSQLParser.GRANT, 0); +}; + +Reserved_keywordContext.prototype.GROUP_P = function() { + return this.getToken(PostgreSQLParser.GROUP_P, 0); +}; + +Reserved_keywordContext.prototype.HAVING = function() { + return this.getToken(PostgreSQLParser.HAVING, 0); +}; + +Reserved_keywordContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +Reserved_keywordContext.prototype.INITIALLY = function() { + return this.getToken(PostgreSQLParser.INITIALLY, 0); +}; + +Reserved_keywordContext.prototype.INTERSECT = function() { + return this.getToken(PostgreSQLParser.INTERSECT, 0); +}; + +Reserved_keywordContext.prototype.LATERAL_P = function() { + return this.getToken(PostgreSQLParser.LATERAL_P, 0); +}; + +Reserved_keywordContext.prototype.LEADING = function() { + return this.getToken(PostgreSQLParser.LEADING, 0); +}; + +Reserved_keywordContext.prototype.LIMIT = function() { + return this.getToken(PostgreSQLParser.LIMIT, 0); +}; + +Reserved_keywordContext.prototype.LOCALTIME = function() { + return this.getToken(PostgreSQLParser.LOCALTIME, 0); +}; + +Reserved_keywordContext.prototype.LOCALTIMESTAMP = function() { + return this.getToken(PostgreSQLParser.LOCALTIMESTAMP, 0); +}; + +Reserved_keywordContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +Reserved_keywordContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +Reserved_keywordContext.prototype.OFFSET = function() { + return this.getToken(PostgreSQLParser.OFFSET, 0); +}; + +Reserved_keywordContext.prototype.ON = function() { + return this.getToken(PostgreSQLParser.ON, 0); +}; + +Reserved_keywordContext.prototype.ONLY = function() { + return this.getToken(PostgreSQLParser.ONLY, 0); +}; + +Reserved_keywordContext.prototype.OR = function() { + return this.getToken(PostgreSQLParser.OR, 0); +}; + +Reserved_keywordContext.prototype.ORDER = function() { + return this.getToken(PostgreSQLParser.ORDER, 0); +}; + +Reserved_keywordContext.prototype.PLACING = function() { + return this.getToken(PostgreSQLParser.PLACING, 0); +}; + +Reserved_keywordContext.prototype.PRIMARY = function() { + return this.getToken(PostgreSQLParser.PRIMARY, 0); +}; + +Reserved_keywordContext.prototype.REFERENCES = function() { + return this.getToken(PostgreSQLParser.REFERENCES, 0); +}; + +Reserved_keywordContext.prototype.RETURNING = function() { + return this.getToken(PostgreSQLParser.RETURNING, 0); +}; + +Reserved_keywordContext.prototype.SELECT = function() { + return this.getToken(PostgreSQLParser.SELECT, 0); +}; + +Reserved_keywordContext.prototype.SESSION_USER = function() { + return this.getToken(PostgreSQLParser.SESSION_USER, 0); +}; + +Reserved_keywordContext.prototype.SOME = function() { + return this.getToken(PostgreSQLParser.SOME, 0); +}; + +Reserved_keywordContext.prototype.SYMMETRIC = function() { + return this.getToken(PostgreSQLParser.SYMMETRIC, 0); +}; + +Reserved_keywordContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +Reserved_keywordContext.prototype.THEN = function() { + return this.getToken(PostgreSQLParser.THEN, 0); +}; + +Reserved_keywordContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +Reserved_keywordContext.prototype.TRAILING = function() { + return this.getToken(PostgreSQLParser.TRAILING, 0); +}; + +Reserved_keywordContext.prototype.TRUE_P = function() { + return this.getToken(PostgreSQLParser.TRUE_P, 0); +}; + +Reserved_keywordContext.prototype.UNION = function() { + return this.getToken(PostgreSQLParser.UNION, 0); +}; + +Reserved_keywordContext.prototype.UNIQUE = function() { + return this.getToken(PostgreSQLParser.UNIQUE, 0); +}; + +Reserved_keywordContext.prototype.USER = function() { + return this.getToken(PostgreSQLParser.USER, 0); +}; + +Reserved_keywordContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Reserved_keywordContext.prototype.VARIADIC = function() { + return this.getToken(PostgreSQLParser.VARIADIC, 0); +}; + +Reserved_keywordContext.prototype.WHEN = function() { + return this.getToken(PostgreSQLParser.WHEN, 0); +}; + +Reserved_keywordContext.prototype.WHERE = function() { + return this.getToken(PostgreSQLParser.WHERE, 0); +}; + +Reserved_keywordContext.prototype.WINDOW = function() { + return this.getToken(PostgreSQLParser.WINDOW, 0); +}; + +Reserved_keywordContext.prototype.WITH = function() { + return this.getToken(PostgreSQLParser.WITH, 0); +}; + +Reserved_keywordContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterReserved_keyword(this); + } +}; + +Reserved_keywordContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitReserved_keyword(this); + } +}; + +Reserved_keywordContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitReserved_keyword(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Reserved_keywordContext = Reserved_keywordContext; + +PostgreSQLParser.prototype.reserved_keyword = function() { + + var localctx = new Reserved_keywordContext(this, this._ctx, this.state); + this.enterRule(localctx, 1378, PostgreSQLParser.RULE_reserved_keyword); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9816; + _la = this._input.LA(1); + if(!(((((_la - 30)) & ~0x1f) == 0 && ((1 << (_la - 30)) & ((1 << (PostgreSQLParser.ALL - 30)) | (1 << (PostgreSQLParser.ANALYSE - 30)) | (1 << (PostgreSQLParser.ANALYZE - 30)) | (1 << (PostgreSQLParser.AND - 30)) | (1 << (PostgreSQLParser.ANY - 30)) | (1 << (PostgreSQLParser.ARRAY - 30)) | (1 << (PostgreSQLParser.AS - 30)) | (1 << (PostgreSQLParser.ASC - 30)) | (1 << (PostgreSQLParser.ASYMMETRIC - 30)) | (1 << (PostgreSQLParser.BOTH - 30)) | (1 << (PostgreSQLParser.CASE - 30)) | (1 << (PostgreSQLParser.CAST - 30)) | (1 << (PostgreSQLParser.CHECK - 30)) | (1 << (PostgreSQLParser.COLLATE - 30)) | (1 << (PostgreSQLParser.COLUMN - 30)) | (1 << (PostgreSQLParser.CONSTRAINT - 30)) | (1 << (PostgreSQLParser.CREATE - 30)) | (1 << (PostgreSQLParser.CURRENT_CATALOG - 30)) | (1 << (PostgreSQLParser.CURRENT_DATE - 30)) | (1 << (PostgreSQLParser.CURRENT_ROLE - 30)) | (1 << (PostgreSQLParser.CURRENT_TIME - 30)) | (1 << (PostgreSQLParser.CURRENT_TIMESTAMP - 30)) | (1 << (PostgreSQLParser.CURRENT_USER - 30)) | (1 << (PostgreSQLParser.DEFERRABLE - 30)) | (1 << (PostgreSQLParser.DESC - 30)) | (1 << (PostgreSQLParser.DISTINCT - 30)) | (1 << (PostgreSQLParser.DO - 30)) | (1 << (PostgreSQLParser.ELSE - 30)) | (1 << (PostgreSQLParser.EXCEPT - 30)) | (1 << (PostgreSQLParser.FALSE_P - 30)) | (1 << (PostgreSQLParser.FETCH - 30)))) !== 0) || ((((_la - 62)) & ~0x1f) == 0 && ((1 << (_la - 62)) & ((1 << (PostgreSQLParser.FOR - 62)) | (1 << (PostgreSQLParser.FOREIGN - 62)) | (1 << (PostgreSQLParser.FROM - 62)) | (1 << (PostgreSQLParser.GRANT - 62)) | (1 << (PostgreSQLParser.GROUP_P - 62)) | (1 << (PostgreSQLParser.HAVING - 62)) | (1 << (PostgreSQLParser.IN_P - 62)) | (1 << (PostgreSQLParser.INITIALLY - 62)) | (1 << (PostgreSQLParser.INTERSECT - 62)) | (1 << (PostgreSQLParser.LATERAL_P - 62)) | (1 << (PostgreSQLParser.LEADING - 62)) | (1 << (PostgreSQLParser.LIMIT - 62)) | (1 << (PostgreSQLParser.LOCALTIME - 62)) | (1 << (PostgreSQLParser.LOCALTIMESTAMP - 62)) | (1 << (PostgreSQLParser.NOT - 62)) | (1 << (PostgreSQLParser.NULL_P - 62)) | (1 << (PostgreSQLParser.OFFSET - 62)) | (1 << (PostgreSQLParser.ON - 62)) | (1 << (PostgreSQLParser.ONLY - 62)) | (1 << (PostgreSQLParser.OR - 62)) | (1 << (PostgreSQLParser.ORDER - 62)) | (1 << (PostgreSQLParser.PLACING - 62)) | (1 << (PostgreSQLParser.PRIMARY - 62)) | (1 << (PostgreSQLParser.REFERENCES - 62)) | (1 << (PostgreSQLParser.RETURNING - 62)) | (1 << (PostgreSQLParser.SELECT - 62)) | (1 << (PostgreSQLParser.SESSION_USER - 62)) | (1 << (PostgreSQLParser.SOME - 62)) | (1 << (PostgreSQLParser.SYMMETRIC - 62)) | (1 << (PostgreSQLParser.TABLE - 62)) | (1 << (PostgreSQLParser.THEN - 62)))) !== 0) || ((((_la - 94)) & ~0x1f) == 0 && ((1 << (_la - 94)) & ((1 << (PostgreSQLParser.TO - 94)) | (1 << (PostgreSQLParser.TRAILING - 94)) | (1 << (PostgreSQLParser.TRUE_P - 94)) | (1 << (PostgreSQLParser.UNION - 94)) | (1 << (PostgreSQLParser.UNIQUE - 94)) | (1 << (PostgreSQLParser.USER - 94)) | (1 << (PostgreSQLParser.USING - 94)) | (1 << (PostgreSQLParser.VARIADIC - 94)) | (1 << (PostgreSQLParser.WHEN - 94)) | (1 << (PostgreSQLParser.WHERE - 94)) | (1 << (PostgreSQLParser.WINDOW - 94)) | (1 << (PostgreSQLParser.WITH - 94)))) !== 0) || _la===PostgreSQLParser.END_P)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Pl_functionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_pl_function; + return this; +} + +Pl_functionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Pl_functionContext.prototype.constructor = Pl_functionContext; + +Pl_functionContext.prototype.comp_options = function() { + return this.getTypedRuleContext(Comp_optionsContext,0); +}; + +Pl_functionContext.prototype.pl_block = function() { + return this.getTypedRuleContext(Pl_blockContext,0); +}; + +Pl_functionContext.prototype.opt_semi = function() { + return this.getTypedRuleContext(Opt_semiContext,0); +}; + +Pl_functionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPl_function(this); + } +}; + +Pl_functionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPl_function(this); + } +}; + +Pl_functionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPl_function(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Pl_functionContext = Pl_functionContext; + +PostgreSQLParser.prototype.pl_function = function() { + + var localctx = new Pl_functionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1380, PostgreSQLParser.RULE_pl_function); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9818; + this.comp_options(); + this.state = 9819; + this.pl_block(); + this.state = 9820; + this.opt_semi(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Comp_optionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_comp_options; + return this; +} + +Comp_optionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Comp_optionsContext.prototype.constructor = Comp_optionsContext; + +Comp_optionsContext.prototype.comp_option = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Comp_optionContext); + } else { + return this.getTypedRuleContext(Comp_optionContext,i); + } +}; + +Comp_optionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterComp_options(this); + } +}; + +Comp_optionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitComp_options(this); + } +}; + +Comp_optionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitComp_options(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Comp_optionsContext = Comp_optionsContext; + +PostgreSQLParser.prototype.comp_options = function() { + + var localctx = new Comp_optionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 1382, PostgreSQLParser.RULE_comp_options); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9825; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.Operator) { + this.state = 9822; + this.comp_option(); + this.state = 9827; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Comp_optionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_comp_option; + return this; +} + +Comp_optionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Comp_optionContext.prototype.constructor = Comp_optionContext; + +Comp_optionContext.prototype.sharp = function() { + return this.getTypedRuleContext(SharpContext,0); +}; + +Comp_optionContext.prototype.OPTION = function() { + return this.getToken(PostgreSQLParser.OPTION, 0); +}; + +Comp_optionContext.prototype.DUMP = function() { + return this.getToken(PostgreSQLParser.DUMP, 0); +}; + +Comp_optionContext.prototype.PRINT_STRICT_PARAMS = function() { + return this.getToken(PostgreSQLParser.PRINT_STRICT_PARAMS, 0); +}; + +Comp_optionContext.prototype.option_value = function() { + return this.getTypedRuleContext(Option_valueContext,0); +}; + +Comp_optionContext.prototype.VARIABLE_CONFLICT = function() { + return this.getToken(PostgreSQLParser.VARIABLE_CONFLICT, 0); +}; + +Comp_optionContext.prototype.ERROR = function() { + return this.getToken(PostgreSQLParser.ERROR, 0); +}; + +Comp_optionContext.prototype.USE_VARIABLE = function() { + return this.getToken(PostgreSQLParser.USE_VARIABLE, 0); +}; + +Comp_optionContext.prototype.USE_COLUMN = function() { + return this.getToken(PostgreSQLParser.USE_COLUMN, 0); +}; + +Comp_optionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterComp_option(this); + } +}; + +Comp_optionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitComp_option(this); + } +}; + +Comp_optionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitComp_option(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Comp_optionContext = Comp_optionContext; + +PostgreSQLParser.prototype.comp_option = function() { + + var localctx = new Comp_optionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1384, PostgreSQLParser.RULE_comp_option); + try { + this.state = 9848; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,644,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9828; + this.sharp(); + this.state = 9829; + this.match(PostgreSQLParser.OPTION); + this.state = 9830; + this.match(PostgreSQLParser.DUMP); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9832; + this.sharp(); + this.state = 9833; + this.match(PostgreSQLParser.PRINT_STRICT_PARAMS); + this.state = 9834; + this.option_value(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9836; + this.sharp(); + this.state = 9837; + this.match(PostgreSQLParser.VARIABLE_CONFLICT); + this.state = 9838; + this.match(PostgreSQLParser.ERROR); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9840; + this.sharp(); + this.state = 9841; + this.match(PostgreSQLParser.VARIABLE_CONFLICT); + this.state = 9842; + this.match(PostgreSQLParser.USE_VARIABLE); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 9844; + this.sharp(); + this.state = 9845; + this.match(PostgreSQLParser.VARIABLE_CONFLICT); + this.state = 9846; + this.match(PostgreSQLParser.USE_COLUMN); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function SharpContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_sharp; + return this; +} + +SharpContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +SharpContext.prototype.constructor = SharpContext; + +SharpContext.prototype.Operator = function() { + return this.getToken(PostgreSQLParser.Operator, 0); +}; + +SharpContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSharp(this); + } +}; + +SharpContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSharp(this); + } +}; + +SharpContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSharp(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.SharpContext = SharpContext; + +PostgreSQLParser.prototype.sharp = function() { + + var localctx = new SharpContext(this, this._ctx, this.state); + this.enterRule(localctx, 1386, PostgreSQLParser.RULE_sharp); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9850; + this.match(PostgreSQLParser.Operator); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Option_valueContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_option_value; + return this; +} + +Option_valueContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Option_valueContext.prototype.constructor = Option_valueContext; + +Option_valueContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Option_valueContext.prototype.reserved_keyword = function() { + return this.getTypedRuleContext(Reserved_keywordContext,0); +}; + +Option_valueContext.prototype.plsql_unreserved_keyword = function() { + return this.getTypedRuleContext(Plsql_unreserved_keywordContext,0); +}; + +Option_valueContext.prototype.unreserved_keyword = function() { + return this.getTypedRuleContext(Unreserved_keywordContext,0); +}; + +Option_valueContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOption_value(this); + } +}; + +Option_valueContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOption_value(this); + } +}; + +Option_valueContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOption_value(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Option_valueContext = Option_valueContext; + +PostgreSQLParser.prototype.option_value = function() { + + var localctx = new Option_valueContext(this, this._ctx, this.state); + this.enterRule(localctx, 1388, PostgreSQLParser.RULE_option_value); + try { + this.state = 9856; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,645,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9852; + this.sconst(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9853; + this.reserved_keyword(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9854; + this.plsql_unreserved_keyword(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9855; + this.unreserved_keyword(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_semiContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_semi; + return this; +} + +Opt_semiContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_semiContext.prototype.constructor = Opt_semiContext; + +Opt_semiContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Opt_semiContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_semi(this); + } +}; + +Opt_semiContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_semi(this); + } +}; + +Opt_semiContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_semi(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_semiContext = Opt_semiContext; + +PostgreSQLParser.prototype.opt_semi = function() { + + var localctx = new Opt_semiContext(this, this._ctx, this.state); + this.enterRule(localctx, 1390, PostgreSQLParser.RULE_opt_semi); + try { + this.state = 9860; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.EOF: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.SEMI: + this.enterOuterAlt(localctx, 2); + this.state = 9859; + this.match(PostgreSQLParser.SEMI); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Pl_blockContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_pl_block; + return this; +} + +Pl_blockContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Pl_blockContext.prototype.constructor = Pl_blockContext; + +Pl_blockContext.prototype.decl_sect = function() { + return this.getTypedRuleContext(Decl_sectContext,0); +}; + +Pl_blockContext.prototype.BEGIN_P = function() { + return this.getToken(PostgreSQLParser.BEGIN_P, 0); +}; + +Pl_blockContext.prototype.proc_sect = function() { + return this.getTypedRuleContext(Proc_sectContext,0); +}; + +Pl_blockContext.prototype.exception_sect = function() { + return this.getTypedRuleContext(Exception_sectContext,0); +}; + +Pl_blockContext.prototype.END_P = function() { + return this.getToken(PostgreSQLParser.END_P, 0); +}; + +Pl_blockContext.prototype.opt_label = function() { + return this.getTypedRuleContext(Opt_labelContext,0); +}; + +Pl_blockContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPl_block(this); + } +}; + +Pl_blockContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPl_block(this); + } +}; + +Pl_blockContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPl_block(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Pl_blockContext = Pl_blockContext; + +PostgreSQLParser.prototype.pl_block = function() { + + var localctx = new Pl_blockContext(this, this._ctx, this.state); + this.enterRule(localctx, 1392, PostgreSQLParser.RULE_pl_block); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9862; + this.decl_sect(); + this.state = 9863; + this.match(PostgreSQLParser.BEGIN_P); + this.state = 9864; + this.proc_sect(); + this.state = 9865; + this.exception_sect(); + this.state = 9866; + this.match(PostgreSQLParser.END_P); + this.state = 9867; + this.opt_label(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_sectContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_sect; + return this; +} + +Decl_sectContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_sectContext.prototype.constructor = Decl_sectContext; + +Decl_sectContext.prototype.opt_block_label = function() { + return this.getTypedRuleContext(Opt_block_labelContext,0); +}; + +Decl_sectContext.prototype.decl_start = function() { + return this.getTypedRuleContext(Decl_startContext,0); +}; + +Decl_sectContext.prototype.decl_stmts = function() { + return this.getTypedRuleContext(Decl_stmtsContext,0); +}; + +Decl_sectContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_sect(this); + } +}; + +Decl_sectContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_sect(this); + } +}; + +Decl_sectContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_sect(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_sectContext = Decl_sectContext; + +PostgreSQLParser.prototype.decl_sect = function() { + + var localctx = new Decl_sectContext(this, this._ctx, this.state); + this.enterRule(localctx, 1394, PostgreSQLParser.RULE_decl_sect); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9869; + this.opt_block_label(); + this.state = 9874; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.DECLARE) { + this.state = 9870; + this.decl_start(); + this.state = 9872; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,647,this._ctx); + if(la_===1) { + this.state = 9871; + this.decl_stmts(); + + } + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_startContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_start; + return this; +} + +Decl_startContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_startContext.prototype.constructor = Decl_startContext; + +Decl_startContext.prototype.DECLARE = function() { + return this.getToken(PostgreSQLParser.DECLARE, 0); +}; + +Decl_startContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_start(this); + } +}; + +Decl_startContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_start(this); + } +}; + +Decl_startContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_start(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_startContext = Decl_startContext; + +PostgreSQLParser.prototype.decl_start = function() { + + var localctx = new Decl_startContext(this, this._ctx, this.state); + this.enterRule(localctx, 1396, PostgreSQLParser.RULE_decl_start); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9876; + this.match(PostgreSQLParser.DECLARE); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_stmtsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_stmts; + return this; +} + +Decl_stmtsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_stmtsContext.prototype.constructor = Decl_stmtsContext; + +Decl_stmtsContext.prototype.decl_stmt = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Decl_stmtContext); + } else { + return this.getTypedRuleContext(Decl_stmtContext,i); + } +}; + +Decl_stmtsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_stmts(this); + } +}; + +Decl_stmtsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_stmts(this); + } +}; + +Decl_stmtsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_stmts(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_stmtsContext = Decl_stmtsContext; + +PostgreSQLParser.prototype.decl_stmts = function() { + + var localctx = new Decl_stmtsContext(this, this._ctx, this.state); + this.enterRule(localctx, 1398, PostgreSQLParser.RULE_decl_stmts); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9879; + this._errHandler.sync(this); + var _alt = 1; + do { + switch (_alt) { + case 1: + this.state = 9878; + this.decl_stmt(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 9881; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,649, this._ctx); + } while ( _alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER ); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Label_declContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_label_decl; + return this; +} + +Label_declContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Label_declContext.prototype.constructor = Label_declContext; + +Label_declContext.prototype.LESS_LESS = function() { + return this.getToken(PostgreSQLParser.LESS_LESS, 0); +}; + +Label_declContext.prototype.any_identifier = function() { + return this.getTypedRuleContext(Any_identifierContext,0); +}; + +Label_declContext.prototype.GREATER_GREATER = function() { + return this.getToken(PostgreSQLParser.GREATER_GREATER, 0); +}; + +Label_declContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterLabel_decl(this); + } +}; + +Label_declContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitLabel_decl(this); + } +}; + +Label_declContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitLabel_decl(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Label_declContext = Label_declContext; + +PostgreSQLParser.prototype.label_decl = function() { + + var localctx = new Label_declContext(this, this._ctx, this.state); + this.enterRule(localctx, 1400, PostgreSQLParser.RULE_label_decl); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9883; + this.match(PostgreSQLParser.LESS_LESS); + this.state = 9884; + this.any_identifier(); + this.state = 9885; + this.match(PostgreSQLParser.GREATER_GREATER); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_stmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_stmt; + return this; +} + +Decl_stmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_stmtContext.prototype.constructor = Decl_stmtContext; + +Decl_stmtContext.prototype.decl_statement = function() { + return this.getTypedRuleContext(Decl_statementContext,0); +}; + +Decl_stmtContext.prototype.DECLARE = function() { + return this.getToken(PostgreSQLParser.DECLARE, 0); +}; + +Decl_stmtContext.prototype.label_decl = function() { + return this.getTypedRuleContext(Label_declContext,0); +}; + +Decl_stmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_stmt(this); + } +}; + +Decl_stmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_stmt(this); + } +}; + +Decl_stmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_stmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_stmtContext = Decl_stmtContext; + +PostgreSQLParser.prototype.decl_stmt = function() { + + var localctx = new Decl_stmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 1402, PostgreSQLParser.RULE_decl_stmt); + try { + this.state = 9890; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,650,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9887; + this.decl_statement(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9888; + this.match(PostgreSQLParser.DECLARE); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9889; + this.label_decl(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_statementContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_statement; + return this; +} + +Decl_statementContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_statementContext.prototype.constructor = Decl_statementContext; + +Decl_statementContext.prototype.decl_varname = function() { + return this.getTypedRuleContext(Decl_varnameContext,0); +}; + +Decl_statementContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Decl_statementContext.prototype.ALIAS = function() { + return this.getToken(PostgreSQLParser.ALIAS, 0); +}; + +Decl_statementContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Decl_statementContext.prototype.decl_aliasitem = function() { + return this.getTypedRuleContext(Decl_aliasitemContext,0); +}; + +Decl_statementContext.prototype.decl_const = function() { + return this.getTypedRuleContext(Decl_constContext,0); +}; + +Decl_statementContext.prototype.decl_datatype = function() { + return this.getTypedRuleContext(Decl_datatypeContext,0); +}; + +Decl_statementContext.prototype.decl_collate = function() { + return this.getTypedRuleContext(Decl_collateContext,0); +}; + +Decl_statementContext.prototype.decl_notnull = function() { + return this.getTypedRuleContext(Decl_notnullContext,0); +}; + +Decl_statementContext.prototype.decl_defval = function() { + return this.getTypedRuleContext(Decl_defvalContext,0); +}; + +Decl_statementContext.prototype.opt_scrollable = function() { + return this.getTypedRuleContext(Opt_scrollableContext,0); +}; + +Decl_statementContext.prototype.CURSOR = function() { + return this.getToken(PostgreSQLParser.CURSOR, 0); +}; + +Decl_statementContext.prototype.decl_cursor_args = function() { + return this.getTypedRuleContext(Decl_cursor_argsContext,0); +}; + +Decl_statementContext.prototype.decl_is_for = function() { + return this.getTypedRuleContext(Decl_is_forContext,0); +}; + +Decl_statementContext.prototype.decl_cursor_query = function() { + return this.getTypedRuleContext(Decl_cursor_queryContext,0); +}; + +Decl_statementContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_statement(this); + } +}; + +Decl_statementContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_statement(this); + } +}; + +Decl_statementContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_statement(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_statementContext = Decl_statementContext; + +PostgreSQLParser.prototype.decl_statement = function() { + + var localctx = new Decl_statementContext(this, this._ctx, this.state); + this.enterRule(localctx, 1404, PostgreSQLParser.RULE_decl_statement); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9892; + this.decl_varname(); + this.state = 9908; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,651,this._ctx); + switch(la_) { + case 1: + this.state = 9893; + this.match(PostgreSQLParser.ALIAS); + this.state = 9894; + this.match(PostgreSQLParser.FOR); + this.state = 9895; + this.decl_aliasitem(); + break; + + case 2: + this.state = 9896; + this.decl_const(); + this.state = 9897; + this.decl_datatype(); + this.state = 9898; + this.decl_collate(); + this.state = 9899; + this.decl_notnull(); + this.state = 9900; + this.decl_defval(); + break; + + case 3: + this.state = 9902; + this.opt_scrollable(); + this.state = 9903; + this.match(PostgreSQLParser.CURSOR); + this.state = 9904; + this.decl_cursor_args(); + this.state = 9905; + this.decl_is_for(); + this.state = 9906; + this.decl_cursor_query(); + break; + + } + this.state = 9910; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_scrollableContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_scrollable; + return this; +} + +Opt_scrollableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_scrollableContext.prototype.constructor = Opt_scrollableContext; + +Opt_scrollableContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Opt_scrollableContext.prototype.SCROLL = function() { + return this.getToken(PostgreSQLParser.SCROLL, 0); +}; + +Opt_scrollableContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_scrollable(this); + } +}; + +Opt_scrollableContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_scrollable(this); + } +}; + +Opt_scrollableContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_scrollable(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_scrollableContext = Opt_scrollableContext; + +PostgreSQLParser.prototype.opt_scrollable = function() { + + var localctx = new Opt_scrollableContext(this, this._ctx, this.state); + this.enterRule(localctx, 1406, PostgreSQLParser.RULE_opt_scrollable); + try { + this.state = 9916; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CURSOR: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.NO: + this.enterOuterAlt(localctx, 2); + this.state = 9913; + this.match(PostgreSQLParser.NO); + this.state = 9914; + this.match(PostgreSQLParser.SCROLL); + break; + case PostgreSQLParser.SCROLL: + this.enterOuterAlt(localctx, 3); + this.state = 9915; + this.match(PostgreSQLParser.SCROLL); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_cursor_queryContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_cursor_query; + return this; +} + +Decl_cursor_queryContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_cursor_queryContext.prototype.constructor = Decl_cursor_queryContext; + +Decl_cursor_queryContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +Decl_cursor_queryContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_cursor_query(this); + } +}; + +Decl_cursor_queryContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_cursor_query(this); + } +}; + +Decl_cursor_queryContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_cursor_query(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_cursor_queryContext = Decl_cursor_queryContext; + +PostgreSQLParser.prototype.decl_cursor_query = function() { + + var localctx = new Decl_cursor_queryContext(this, this._ctx, this.state); + this.enterRule(localctx, 1408, PostgreSQLParser.RULE_decl_cursor_query); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9918; + this.selectstmt(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_cursor_argsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_cursor_args; + return this; +} + +Decl_cursor_argsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_cursor_argsContext.prototype.constructor = Decl_cursor_argsContext; + +Decl_cursor_argsContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Decl_cursor_argsContext.prototype.decl_cursor_arglist = function() { + return this.getTypedRuleContext(Decl_cursor_arglistContext,0); +}; + +Decl_cursor_argsContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Decl_cursor_argsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_cursor_args(this); + } +}; + +Decl_cursor_argsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_cursor_args(this); + } +}; + +Decl_cursor_argsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_cursor_args(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_cursor_argsContext = Decl_cursor_argsContext; + +PostgreSQLParser.prototype.decl_cursor_args = function() { + + var localctx = new Decl_cursor_argsContext(this, this._ctx, this.state); + this.enterRule(localctx, 1410, PostgreSQLParser.RULE_decl_cursor_args); + try { + this.state = 9925; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FOR: + case PostgreSQLParser.IS: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.OPEN_PAREN: + this.enterOuterAlt(localctx, 2); + this.state = 9921; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 9922; + this.decl_cursor_arglist(); + this.state = 9923; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_cursor_arglistContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_cursor_arglist; + return this; +} + +Decl_cursor_arglistContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_cursor_arglistContext.prototype.constructor = Decl_cursor_arglistContext; + +Decl_cursor_arglistContext.prototype.decl_cursor_arg = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Decl_cursor_argContext); + } else { + return this.getTypedRuleContext(Decl_cursor_argContext,i); + } +}; + +Decl_cursor_arglistContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Decl_cursor_arglistContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_cursor_arglist(this); + } +}; + +Decl_cursor_arglistContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_cursor_arglist(this); + } +}; + +Decl_cursor_arglistContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_cursor_arglist(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_cursor_arglistContext = Decl_cursor_arglistContext; + +PostgreSQLParser.prototype.decl_cursor_arglist = function() { + + var localctx = new Decl_cursor_arglistContext(this, this._ctx, this.state); + this.enterRule(localctx, 1412, PostgreSQLParser.RULE_decl_cursor_arglist); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9927; + this.decl_cursor_arg(); + this.state = 9932; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 9928; + this.match(PostgreSQLParser.COMMA); + this.state = 9929; + this.decl_cursor_arg(); + this.state = 9934; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_cursor_argContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_cursor_arg; + return this; +} + +Decl_cursor_argContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_cursor_argContext.prototype.constructor = Decl_cursor_argContext; + +Decl_cursor_argContext.prototype.decl_varname = function() { + return this.getTypedRuleContext(Decl_varnameContext,0); +}; + +Decl_cursor_argContext.prototype.decl_datatype = function() { + return this.getTypedRuleContext(Decl_datatypeContext,0); +}; + +Decl_cursor_argContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_cursor_arg(this); + } +}; + +Decl_cursor_argContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_cursor_arg(this); + } +}; + +Decl_cursor_argContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_cursor_arg(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_cursor_argContext = Decl_cursor_argContext; + +PostgreSQLParser.prototype.decl_cursor_arg = function() { + + var localctx = new Decl_cursor_argContext(this, this._ctx, this.state); + this.enterRule(localctx, 1414, PostgreSQLParser.RULE_decl_cursor_arg); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9935; + this.decl_varname(); + this.state = 9936; + this.decl_datatype(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_is_forContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_is_for; + return this; +} + +Decl_is_forContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_is_forContext.prototype.constructor = Decl_is_forContext; + +Decl_is_forContext.prototype.IS = function() { + return this.getToken(PostgreSQLParser.IS, 0); +}; + +Decl_is_forContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Decl_is_forContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_is_for(this); + } +}; + +Decl_is_forContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_is_for(this); + } +}; + +Decl_is_forContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_is_for(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_is_forContext = Decl_is_forContext; + +PostgreSQLParser.prototype.decl_is_for = function() { + + var localctx = new Decl_is_forContext(this, this._ctx, this.state); + this.enterRule(localctx, 1416, PostgreSQLParser.RULE_decl_is_for); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9938; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.FOR || _la===PostgreSQLParser.IS)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_aliasitemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_aliasitem; + return this; +} + +Decl_aliasitemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_aliasitemContext.prototype.constructor = Decl_aliasitemContext; + +Decl_aliasitemContext.prototype.PARAM = function() { + return this.getToken(PostgreSQLParser.PARAM, 0); +}; + +Decl_aliasitemContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Decl_aliasitemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_aliasitem(this); + } +}; + +Decl_aliasitemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_aliasitem(this); + } +}; + +Decl_aliasitemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_aliasitem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_aliasitemContext = Decl_aliasitemContext; + +PostgreSQLParser.prototype.decl_aliasitem = function() { + + var localctx = new Decl_aliasitemContext(this, this._ctx, this.state); + this.enterRule(localctx, 1418, PostgreSQLParser.RULE_decl_aliasitem); + try { + this.state = 9942; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.PARAM: + this.enterOuterAlt(localctx, 1); + this.state = 9940; + this.match(PostgreSQLParser.PARAM); + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 2); + this.state = 9941; + this.colid(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_varnameContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_varname; + return this; +} + +Decl_varnameContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_varnameContext.prototype.constructor = Decl_varnameContext; + +Decl_varnameContext.prototype.any_identifier = function() { + return this.getTypedRuleContext(Any_identifierContext,0); +}; + +Decl_varnameContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_varname(this); + } +}; + +Decl_varnameContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_varname(this); + } +}; + +Decl_varnameContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_varname(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_varnameContext = Decl_varnameContext; + +PostgreSQLParser.prototype.decl_varname = function() { + + var localctx = new Decl_varnameContext(this, this._ctx, this.state); + this.enterRule(localctx, 1420, PostgreSQLParser.RULE_decl_varname); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9944; + this.any_identifier(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_constContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_const; + return this; +} + +Decl_constContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_constContext.prototype.constructor = Decl_constContext; + +Decl_constContext.prototype.CONSTANT = function() { + return this.getToken(PostgreSQLParser.CONSTANT, 0); +}; + +Decl_constContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_const(this); + } +}; + +Decl_constContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_const(this); + } +}; + +Decl_constContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_const(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_constContext = Decl_constContext; + +PostgreSQLParser.prototype.decl_const = function() { + + var localctx = new Decl_constContext(this, this._ctx, this.state); + this.enterRule(localctx, 1422, PostgreSQLParser.RULE_decl_const); + try { + this.state = 9948; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,656,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9947; + this.match(PostgreSQLParser.CONSTANT); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_datatypeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_datatype; + return this; +} + +Decl_datatypeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_datatypeContext.prototype.constructor = Decl_datatypeContext; + +Decl_datatypeContext.prototype.typename = function() { + return this.getTypedRuleContext(TypenameContext,0); +}; + +Decl_datatypeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_datatype(this); + } +}; + +Decl_datatypeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_datatype(this); + } +}; + +Decl_datatypeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_datatype(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_datatypeContext = Decl_datatypeContext; + +PostgreSQLParser.prototype.decl_datatype = function() { + + var localctx = new Decl_datatypeContext(this, this._ctx, this.state); + this.enterRule(localctx, 1424, PostgreSQLParser.RULE_decl_datatype); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9950; + this.typename(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_collateContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_collate; + return this; +} + +Decl_collateContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_collateContext.prototype.constructor = Decl_collateContext; + +Decl_collateContext.prototype.COLLATE = function() { + return this.getToken(PostgreSQLParser.COLLATE, 0); +}; + +Decl_collateContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Decl_collateContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_collate(this); + } +}; + +Decl_collateContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_collate(this); + } +}; + +Decl_collateContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_collate(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_collateContext = Decl_collateContext; + +PostgreSQLParser.prototype.decl_collate = function() { + + var localctx = new Decl_collateContext(this, this._ctx, this.state); + this.enterRule(localctx, 1426, PostgreSQLParser.RULE_decl_collate); + try { + this.state = 9955; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SEMI: + case PostgreSQLParser.EQUAL: + case PostgreSQLParser.COLON_EQUALS: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.NOT: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.COLLATE: + this.enterOuterAlt(localctx, 2); + this.state = 9953; + this.match(PostgreSQLParser.COLLATE); + this.state = 9954; + this.any_name(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_notnullContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_notnull; + return this; +} + +Decl_notnullContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_notnullContext.prototype.constructor = Decl_notnullContext; + +Decl_notnullContext.prototype.NOT = function() { + return this.getToken(PostgreSQLParser.NOT, 0); +}; + +Decl_notnullContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +Decl_notnullContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_notnull(this); + } +}; + +Decl_notnullContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_notnull(this); + } +}; + +Decl_notnullContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_notnull(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_notnullContext = Decl_notnullContext; + +PostgreSQLParser.prototype.decl_notnull = function() { + + var localctx = new Decl_notnullContext(this, this._ctx, this.state); + this.enterRule(localctx, 1428, PostgreSQLParser.RULE_decl_notnull); + try { + this.state = 9960; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SEMI: + case PostgreSQLParser.EQUAL: + case PostgreSQLParser.COLON_EQUALS: + case PostgreSQLParser.DEFAULT: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.NOT: + this.enterOuterAlt(localctx, 2); + this.state = 9958; + this.match(PostgreSQLParser.NOT); + this.state = 9959; + this.match(PostgreSQLParser.NULL_P); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_defvalContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_defval; + return this; +} + +Decl_defvalContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_defvalContext.prototype.constructor = Decl_defvalContext; + +Decl_defvalContext.prototype.decl_defkey = function() { + return this.getTypedRuleContext(Decl_defkeyContext,0); +}; + +Decl_defvalContext.prototype.sql_expression = function() { + return this.getTypedRuleContext(Sql_expressionContext,0); +}; + +Decl_defvalContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_defval(this); + } +}; + +Decl_defvalContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_defval(this); + } +}; + +Decl_defvalContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_defval(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_defvalContext = Decl_defvalContext; + +PostgreSQLParser.prototype.decl_defval = function() { + + var localctx = new Decl_defvalContext(this, this._ctx, this.state); + this.enterRule(localctx, 1430, PostgreSQLParser.RULE_decl_defval); + try { + this.state = 9966; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SEMI: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.EQUAL: + case PostgreSQLParser.COLON_EQUALS: + case PostgreSQLParser.DEFAULT: + this.enterOuterAlt(localctx, 2); + this.state = 9963; + this.decl_defkey(); + this.state = 9964; + this.sql_expression(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Decl_defkeyContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_decl_defkey; + return this; +} + +Decl_defkeyContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Decl_defkeyContext.prototype.constructor = Decl_defkeyContext; + +Decl_defkeyContext.prototype.assign_operator = function() { + return this.getTypedRuleContext(Assign_operatorContext,0); +}; + +Decl_defkeyContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Decl_defkeyContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterDecl_defkey(this); + } +}; + +Decl_defkeyContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitDecl_defkey(this); + } +}; + +Decl_defkeyContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitDecl_defkey(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Decl_defkeyContext = Decl_defkeyContext; + +PostgreSQLParser.prototype.decl_defkey = function() { + + var localctx = new Decl_defkeyContext(this, this._ctx, this.state); + this.enterRule(localctx, 1432, PostgreSQLParser.RULE_decl_defkey); + try { + this.state = 9970; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.EQUAL: + case PostgreSQLParser.COLON_EQUALS: + this.enterOuterAlt(localctx, 1); + this.state = 9968; + this.assign_operator(); + break; + case PostgreSQLParser.DEFAULT: + this.enterOuterAlt(localctx, 2); + this.state = 9969; + this.match(PostgreSQLParser.DEFAULT); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Assign_operatorContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_assign_operator; + return this; +} + +Assign_operatorContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Assign_operatorContext.prototype.constructor = Assign_operatorContext; + +Assign_operatorContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +Assign_operatorContext.prototype.COLON_EQUALS = function() { + return this.getToken(PostgreSQLParser.COLON_EQUALS, 0); +}; + +Assign_operatorContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAssign_operator(this); + } +}; + +Assign_operatorContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAssign_operator(this); + } +}; + +Assign_operatorContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAssign_operator(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Assign_operatorContext = Assign_operatorContext; + +PostgreSQLParser.prototype.assign_operator = function() { + + var localctx = new Assign_operatorContext(this, this._ctx, this.state); + this.enterRule(localctx, 1434, PostgreSQLParser.RULE_assign_operator); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 9972; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.EQUAL || _la===PostgreSQLParser.COLON_EQUALS)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Proc_sectContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_proc_sect; + return this; +} + +Proc_sectContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Proc_sectContext.prototype.constructor = Proc_sectContext; + +Proc_sectContext.prototype.proc_stmt = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Proc_stmtContext); + } else { + return this.getTypedRuleContext(Proc_stmtContext,i); + } +}; + +Proc_sectContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterProc_sect(this); + } +}; + +Proc_sectContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitProc_sect(this); + } +}; + +Proc_sectContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitProc_sect(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Proc_sectContext = Proc_sectContext; + +PostgreSQLParser.prototype.proc_sect = function() { + + var localctx = new Proc_sectContext(this, this._ctx, this.state); + this.enterRule(localctx, 1436, PostgreSQLParser.RULE_proc_sect); + try { + this.enterOuterAlt(localctx, 1); + this.state = 9977; + this._errHandler.sync(this); + var _alt = this._interp.adaptivePredict(this._input,661,this._ctx) + while(_alt!=2 && _alt!=antlr4.atn.ATN.INVALID_ALT_NUMBER) { + if(_alt===1) { + this.state = 9974; + this.proc_stmt(); + } + this.state = 9979; + this._errHandler.sync(this); + _alt = this._interp.adaptivePredict(this._input,661,this._ctx); + } + + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Proc_stmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_proc_stmt; + return this; +} + +Proc_stmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Proc_stmtContext.prototype.constructor = Proc_stmtContext; + +Proc_stmtContext.prototype.pl_block = function() { + return this.getTypedRuleContext(Pl_blockContext,0); +}; + +Proc_stmtContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Proc_stmtContext.prototype.stmt_return = function() { + return this.getTypedRuleContext(Stmt_returnContext,0); +}; + +Proc_stmtContext.prototype.stmt_raise = function() { + return this.getTypedRuleContext(Stmt_raiseContext,0); +}; + +Proc_stmtContext.prototype.stmt_assign = function() { + return this.getTypedRuleContext(Stmt_assignContext,0); +}; + +Proc_stmtContext.prototype.stmt_if = function() { + return this.getTypedRuleContext(Stmt_ifContext,0); +}; + +Proc_stmtContext.prototype.stmt_case = function() { + return this.getTypedRuleContext(Stmt_caseContext,0); +}; + +Proc_stmtContext.prototype.stmt_loop = function() { + return this.getTypedRuleContext(Stmt_loopContext,0); +}; + +Proc_stmtContext.prototype.stmt_while = function() { + return this.getTypedRuleContext(Stmt_whileContext,0); +}; + +Proc_stmtContext.prototype.stmt_for = function() { + return this.getTypedRuleContext(Stmt_forContext,0); +}; + +Proc_stmtContext.prototype.stmt_foreach_a = function() { + return this.getTypedRuleContext(Stmt_foreach_aContext,0); +}; + +Proc_stmtContext.prototype.stmt_exit = function() { + return this.getTypedRuleContext(Stmt_exitContext,0); +}; + +Proc_stmtContext.prototype.stmt_assert = function() { + return this.getTypedRuleContext(Stmt_assertContext,0); +}; + +Proc_stmtContext.prototype.stmt_execsql = function() { + return this.getTypedRuleContext(Stmt_execsqlContext,0); +}; + +Proc_stmtContext.prototype.stmt_dynexecute = function() { + return this.getTypedRuleContext(Stmt_dynexecuteContext,0); +}; + +Proc_stmtContext.prototype.stmt_perform = function() { + return this.getTypedRuleContext(Stmt_performContext,0); +}; + +Proc_stmtContext.prototype.stmt_call = function() { + return this.getTypedRuleContext(Stmt_callContext,0); +}; + +Proc_stmtContext.prototype.stmt_getdiag = function() { + return this.getTypedRuleContext(Stmt_getdiagContext,0); +}; + +Proc_stmtContext.prototype.stmt_open = function() { + return this.getTypedRuleContext(Stmt_openContext,0); +}; + +Proc_stmtContext.prototype.stmt_fetch = function() { + return this.getTypedRuleContext(Stmt_fetchContext,0); +}; + +Proc_stmtContext.prototype.stmt_move = function() { + return this.getTypedRuleContext(Stmt_moveContext,0); +}; + +Proc_stmtContext.prototype.stmt_close = function() { + return this.getTypedRuleContext(Stmt_closeContext,0); +}; + +Proc_stmtContext.prototype.stmt_null = function() { + return this.getTypedRuleContext(Stmt_nullContext,0); +}; + +Proc_stmtContext.prototype.stmt_commit = function() { + return this.getTypedRuleContext(Stmt_commitContext,0); +}; + +Proc_stmtContext.prototype.stmt_rollback = function() { + return this.getTypedRuleContext(Stmt_rollbackContext,0); +}; + +Proc_stmtContext.prototype.stmt_set = function() { + return this.getTypedRuleContext(Stmt_setContext,0); +}; + +Proc_stmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterProc_stmt(this); + } +}; + +Proc_stmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitProc_stmt(this); + } +}; + +Proc_stmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitProc_stmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Proc_stmtContext = Proc_stmtContext; + +PostgreSQLParser.prototype.proc_stmt = function() { + + var localctx = new Proc_stmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 1438, PostgreSQLParser.RULE_proc_stmt); + try { + this.state = 10007; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,662,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 9980; + this.pl_block(); + this.state = 9981; + this.match(PostgreSQLParser.SEMI); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 9983; + this.stmt_return(); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 9984; + this.stmt_raise(); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 9985; + this.stmt_assign(); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 9986; + this.stmt_if(); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 9987; + this.stmt_case(); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 9988; + this.stmt_loop(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 9989; + this.stmt_while(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 9990; + this.stmt_for(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 9991; + this.stmt_foreach_a(); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 9992; + this.stmt_exit(); + break; + + case 12: + this.enterOuterAlt(localctx, 12); + this.state = 9993; + this.stmt_assert(); + break; + + case 13: + this.enterOuterAlt(localctx, 13); + this.state = 9994; + this.stmt_execsql(); + break; + + case 14: + this.enterOuterAlt(localctx, 14); + this.state = 9995; + this.stmt_dynexecute(); + break; + + case 15: + this.enterOuterAlt(localctx, 15); + this.state = 9996; + this.stmt_perform(); + break; + + case 16: + this.enterOuterAlt(localctx, 16); + this.state = 9997; + this.stmt_call(); + break; + + case 17: + this.enterOuterAlt(localctx, 17); + this.state = 9998; + this.stmt_getdiag(); + break; + + case 18: + this.enterOuterAlt(localctx, 18); + this.state = 9999; + this.stmt_open(); + break; + + case 19: + this.enterOuterAlt(localctx, 19); + this.state = 10000; + this.stmt_fetch(); + break; + + case 20: + this.enterOuterAlt(localctx, 20); + this.state = 10001; + this.stmt_move(); + break; + + case 21: + this.enterOuterAlt(localctx, 21); + this.state = 10002; + this.stmt_close(); + break; + + case 22: + this.enterOuterAlt(localctx, 22); + this.state = 10003; + this.stmt_null(); + break; + + case 23: + this.enterOuterAlt(localctx, 23); + this.state = 10004; + this.stmt_commit(); + break; + + case 24: + this.enterOuterAlt(localctx, 24); + this.state = 10005; + this.stmt_rollback(); + break; + + case 25: + this.enterOuterAlt(localctx, 25); + this.state = 10006; + this.stmt_set(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_performContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_perform; + return this; +} + +Stmt_performContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_performContext.prototype.constructor = Stmt_performContext; + +Stmt_performContext.prototype.PERFORM = function() { + return this.getToken(PostgreSQLParser.PERFORM, 0); +}; + +Stmt_performContext.prototype.expr_until_semi = function() { + return this.getTypedRuleContext(Expr_until_semiContext,0); +}; + +Stmt_performContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_performContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_perform(this); + } +}; + +Stmt_performContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_perform(this); + } +}; + +Stmt_performContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_perform(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_performContext = Stmt_performContext; + +PostgreSQLParser.prototype.stmt_perform = function() { + + var localctx = new Stmt_performContext(this, this._ctx, this.state); + this.enterRule(localctx, 1440, PostgreSQLParser.RULE_stmt_perform); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10009; + this.match(PostgreSQLParser.PERFORM); + this.state = 10010; + this.expr_until_semi(); + this.state = 10011; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_callContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_call; + return this; +} + +Stmt_callContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_callContext.prototype.constructor = Stmt_callContext; + +Stmt_callContext.prototype.CALL = function() { + return this.getToken(PostgreSQLParser.CALL, 0); +}; + +Stmt_callContext.prototype.any_identifier = function() { + return this.getTypedRuleContext(Any_identifierContext,0); +}; + +Stmt_callContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Stmt_callContext.prototype.opt_expr_list = function() { + return this.getTypedRuleContext(Opt_expr_listContext,0); +}; + +Stmt_callContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Stmt_callContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_callContext.prototype.DO = function() { + return this.getToken(PostgreSQLParser.DO, 0); +}; + +Stmt_callContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_call(this); + } +}; + +Stmt_callContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_call(this); + } +}; + +Stmt_callContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_call(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_callContext = Stmt_callContext; + +PostgreSQLParser.prototype.stmt_call = function() { + + var localctx = new Stmt_callContext(this, this._ctx, this.state); + this.enterRule(localctx, 1442, PostgreSQLParser.RULE_stmt_call); + try { + this.state = 10027; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CALL: + this.enterOuterAlt(localctx, 1); + this.state = 10013; + this.match(PostgreSQLParser.CALL); + this.state = 10014; + this.any_identifier(); + this.state = 10015; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 10016; + this.opt_expr_list(); + this.state = 10017; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 10018; + this.match(PostgreSQLParser.SEMI); + break; + case PostgreSQLParser.DO: + this.enterOuterAlt(localctx, 2); + this.state = 10020; + this.match(PostgreSQLParser.DO); + this.state = 10021; + this.any_identifier(); + this.state = 10022; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 10023; + this.opt_expr_list(); + this.state = 10024; + this.match(PostgreSQLParser.CLOSE_PAREN); + this.state = 10025; + this.match(PostgreSQLParser.SEMI); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_expr_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_expr_list; + return this; +} + +Opt_expr_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_expr_listContext.prototype.constructor = Opt_expr_listContext; + +Opt_expr_listContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Opt_expr_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_expr_list(this); + } +}; + +Opt_expr_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_expr_list(this); + } +}; + +Opt_expr_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_expr_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_expr_listContext = Opt_expr_listContext; + +PostgreSQLParser.prototype.opt_expr_list = function() { + + var localctx = new Opt_expr_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1444, PostgreSQLParser.RULE_opt_expr_list); + try { + this.state = 10031; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.CLOSE_PAREN: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.PLUS: + case PostgreSQLParser.MINUS: + case PostgreSQLParser.PARAM: + case PostgreSQLParser.Operator: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.CASE: + case PostgreSQLParser.CAST: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.NOT: + case PostgreSQLParser.NULL_P: + case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.USER: + case PostgreSQLParser.AUTHORIZATION: + case PostgreSQLParser.BINARY: + case PostgreSQLParser.COLLATION: + case PostgreSQLParser.CONCURRENTLY: + case PostgreSQLParser.CROSS: + case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.FREEZE: + case PostgreSQLParser.FULL: + case PostgreSQLParser.ILIKE: + case PostgreSQLParser.INNER_P: + case PostgreSQLParser.IS: + case PostgreSQLParser.ISNULL: + case PostgreSQLParser.JOIN: + case PostgreSQLParser.LEFT: + case PostgreSQLParser.LIKE: + case PostgreSQLParser.NATURAL: + case PostgreSQLParser.NOTNULL: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.OVERLAPS: + case PostgreSQLParser.RIGHT: + case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.VERBOSE: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.TABLESAMPLE: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.StringConstant: + case PostgreSQLParser.UnicodeEscapeStringConstant: + case PostgreSQLParser.BeginDollarStringConstant: + case PostgreSQLParser.BinaryStringConstant: + case PostgreSQLParser.HexadecimalStringConstant: + case PostgreSQLParser.Integral: + case PostgreSQLParser.Numeric: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + case PostgreSQLParser.EscapeStringConstant: + this.enterOuterAlt(localctx, 2); + this.state = 10030; + this.expr_list(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_assignContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_assign; + return this; +} + +Stmt_assignContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_assignContext.prototype.constructor = Stmt_assignContext; + +Stmt_assignContext.prototype.assign_var = function() { + return this.getTypedRuleContext(Assign_varContext,0); +}; + +Stmt_assignContext.prototype.assign_operator = function() { + return this.getTypedRuleContext(Assign_operatorContext,0); +}; + +Stmt_assignContext.prototype.sql_expression = function() { + return this.getTypedRuleContext(Sql_expressionContext,0); +}; + +Stmt_assignContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_assignContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_assign(this); + } +}; + +Stmt_assignContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_assign(this); + } +}; + +Stmt_assignContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_assign(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_assignContext = Stmt_assignContext; + +PostgreSQLParser.prototype.stmt_assign = function() { + + var localctx = new Stmt_assignContext(this, this._ctx, this.state); + this.enterRule(localctx, 1446, PostgreSQLParser.RULE_stmt_assign); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10033; + this.assign_var(); + this.state = 10034; + this.assign_operator(); + this.state = 10035; + this.sql_expression(); + this.state = 10036; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_getdiagContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_getdiag; + return this; +} + +Stmt_getdiagContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_getdiagContext.prototype.constructor = Stmt_getdiagContext; + +Stmt_getdiagContext.prototype.GET = function() { + return this.getToken(PostgreSQLParser.GET, 0); +}; + +Stmt_getdiagContext.prototype.getdiag_area_opt = function() { + return this.getTypedRuleContext(Getdiag_area_optContext,0); +}; + +Stmt_getdiagContext.prototype.DIAGNOSTICS = function() { + return this.getToken(PostgreSQLParser.DIAGNOSTICS, 0); +}; + +Stmt_getdiagContext.prototype.getdiag_list = function() { + return this.getTypedRuleContext(Getdiag_listContext,0); +}; + +Stmt_getdiagContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_getdiagContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_getdiag(this); + } +}; + +Stmt_getdiagContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_getdiag(this); + } +}; + +Stmt_getdiagContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_getdiag(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_getdiagContext = Stmt_getdiagContext; + +PostgreSQLParser.prototype.stmt_getdiag = function() { + + var localctx = new Stmt_getdiagContext(this, this._ctx, this.state); + this.enterRule(localctx, 1448, PostgreSQLParser.RULE_stmt_getdiag); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10038; + this.match(PostgreSQLParser.GET); + this.state = 10039; + this.getdiag_area_opt(); + this.state = 10040; + this.match(PostgreSQLParser.DIAGNOSTICS); + this.state = 10041; + this.getdiag_list(); + this.state = 10042; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Getdiag_area_optContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_getdiag_area_opt; + return this; +} + +Getdiag_area_optContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Getdiag_area_optContext.prototype.constructor = Getdiag_area_optContext; + +Getdiag_area_optContext.prototype.CURRENT_P = function() { + return this.getToken(PostgreSQLParser.CURRENT_P, 0); +}; + +Getdiag_area_optContext.prototype.STACKED = function() { + return this.getToken(PostgreSQLParser.STACKED, 0); +}; + +Getdiag_area_optContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGetdiag_area_opt(this); + } +}; + +Getdiag_area_optContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGetdiag_area_opt(this); + } +}; + +Getdiag_area_optContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGetdiag_area_opt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Getdiag_area_optContext = Getdiag_area_optContext; + +PostgreSQLParser.prototype.getdiag_area_opt = function() { + + var localctx = new Getdiag_area_optContext(this, this._ctx, this.state); + this.enterRule(localctx, 1450, PostgreSQLParser.RULE_getdiag_area_opt); + try { + this.state = 10047; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.DIAGNOSTICS: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.CURRENT_P: + this.enterOuterAlt(localctx, 2); + this.state = 10045; + this.match(PostgreSQLParser.CURRENT_P); + break; + case PostgreSQLParser.STACKED: + this.enterOuterAlt(localctx, 3); + this.state = 10046; + this.match(PostgreSQLParser.STACKED); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Getdiag_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_getdiag_list; + return this; +} + +Getdiag_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Getdiag_listContext.prototype.constructor = Getdiag_listContext; + +Getdiag_listContext.prototype.getdiag_list_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Getdiag_list_itemContext); + } else { + return this.getTypedRuleContext(Getdiag_list_itemContext,i); + } +}; + +Getdiag_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Getdiag_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGetdiag_list(this); + } +}; + +Getdiag_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGetdiag_list(this); + } +}; + +Getdiag_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGetdiag_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Getdiag_listContext = Getdiag_listContext; + +PostgreSQLParser.prototype.getdiag_list = function() { + + var localctx = new Getdiag_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1452, PostgreSQLParser.RULE_getdiag_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10049; + this.getdiag_list_item(); + this.state = 10054; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 10050; + this.match(PostgreSQLParser.COMMA); + this.state = 10051; + this.getdiag_list_item(); + this.state = 10056; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Getdiag_list_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_getdiag_list_item; + return this; +} + +Getdiag_list_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Getdiag_list_itemContext.prototype.constructor = Getdiag_list_itemContext; + +Getdiag_list_itemContext.prototype.getdiag_target = function() { + return this.getTypedRuleContext(Getdiag_targetContext,0); +}; + +Getdiag_list_itemContext.prototype.assign_operator = function() { + return this.getTypedRuleContext(Assign_operatorContext,0); +}; + +Getdiag_list_itemContext.prototype.getdiag_item = function() { + return this.getTypedRuleContext(Getdiag_itemContext,0); +}; + +Getdiag_list_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGetdiag_list_item(this); + } +}; + +Getdiag_list_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGetdiag_list_item(this); + } +}; + +Getdiag_list_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGetdiag_list_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Getdiag_list_itemContext = Getdiag_list_itemContext; + +PostgreSQLParser.prototype.getdiag_list_item = function() { + + var localctx = new Getdiag_list_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 1454, PostgreSQLParser.RULE_getdiag_list_item); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10057; + this.getdiag_target(); + this.state = 10058; + this.assign_operator(); + this.state = 10059; + this.getdiag_item(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Getdiag_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_getdiag_item; + return this; +} + +Getdiag_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Getdiag_itemContext.prototype.constructor = Getdiag_itemContext; + +Getdiag_itemContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Getdiag_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGetdiag_item(this); + } +}; + +Getdiag_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGetdiag_item(this); + } +}; + +Getdiag_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGetdiag_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Getdiag_itemContext = Getdiag_itemContext; + +PostgreSQLParser.prototype.getdiag_item = function() { + + var localctx = new Getdiag_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 1456, PostgreSQLParser.RULE_getdiag_item); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10061; + this.colid(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Getdiag_targetContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_getdiag_target; + return this; +} + +Getdiag_targetContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Getdiag_targetContext.prototype.constructor = Getdiag_targetContext; + +Getdiag_targetContext.prototype.assign_var = function() { + return this.getTypedRuleContext(Assign_varContext,0); +}; + +Getdiag_targetContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterGetdiag_target(this); + } +}; + +Getdiag_targetContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitGetdiag_target(this); + } +}; + +Getdiag_targetContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitGetdiag_target(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Getdiag_targetContext = Getdiag_targetContext; + +PostgreSQLParser.prototype.getdiag_target = function() { + + var localctx = new Getdiag_targetContext(this, this._ctx, this.state); + this.enterRule(localctx, 1458, PostgreSQLParser.RULE_getdiag_target); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10063; + this.assign_var(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Assign_varContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_assign_var; + return this; +} + +Assign_varContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Assign_varContext.prototype.constructor = Assign_varContext; + +Assign_varContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Assign_varContext.prototype.PARAM = function() { + return this.getToken(PostgreSQLParser.PARAM, 0); +}; + +Assign_varContext.prototype.OPEN_BRACKET = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.OPEN_BRACKET); + } else { + return this.getToken(PostgreSQLParser.OPEN_BRACKET, i); + } +}; + + +Assign_varContext.prototype.expr_until_rightbracket = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Expr_until_rightbracketContext); + } else { + return this.getTypedRuleContext(Expr_until_rightbracketContext,i); + } +}; + +Assign_varContext.prototype.CLOSE_BRACKET = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.CLOSE_BRACKET); + } else { + return this.getToken(PostgreSQLParser.CLOSE_BRACKET, i); + } +}; + + +Assign_varContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAssign_var(this); + } +}; + +Assign_varContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAssign_var(this); + } +}; + +Assign_varContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAssign_var(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Assign_varContext = Assign_varContext; + +PostgreSQLParser.prototype.assign_var = function() { + + var localctx = new Assign_varContext(this, this._ctx, this.state); + this.enterRule(localctx, 1460, PostgreSQLParser.RULE_assign_var); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10067; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.state = 10065; + this.any_name(); + break; + case PostgreSQLParser.PARAM: + this.state = 10066; + this.match(PostgreSQLParser.PARAM); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 10075; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.OPEN_BRACKET) { + this.state = 10069; + this.match(PostgreSQLParser.OPEN_BRACKET); + this.state = 10070; + this.expr_until_rightbracket(); + this.state = 10071; + this.match(PostgreSQLParser.CLOSE_BRACKET); + this.state = 10077; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_ifContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_if; + return this; +} + +Stmt_ifContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_ifContext.prototype.constructor = Stmt_ifContext; + +Stmt_ifContext.prototype.IF_P = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.IF_P); + } else { + return this.getToken(PostgreSQLParser.IF_P, i); + } +}; + + +Stmt_ifContext.prototype.expr_until_then = function() { + return this.getTypedRuleContext(Expr_until_thenContext,0); +}; + +Stmt_ifContext.prototype.THEN = function() { + return this.getToken(PostgreSQLParser.THEN, 0); +}; + +Stmt_ifContext.prototype.proc_sect = function() { + return this.getTypedRuleContext(Proc_sectContext,0); +}; + +Stmt_ifContext.prototype.stmt_elsifs = function() { + return this.getTypedRuleContext(Stmt_elsifsContext,0); +}; + +Stmt_ifContext.prototype.stmt_else = function() { + return this.getTypedRuleContext(Stmt_elseContext,0); +}; + +Stmt_ifContext.prototype.END_P = function() { + return this.getToken(PostgreSQLParser.END_P, 0); +}; + +Stmt_ifContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_ifContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_if(this); + } +}; + +Stmt_ifContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_if(this); + } +}; + +Stmt_ifContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_if(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_ifContext = Stmt_ifContext; + +PostgreSQLParser.prototype.stmt_if = function() { + + var localctx = new Stmt_ifContext(this, this._ctx, this.state); + this.enterRule(localctx, 1462, PostgreSQLParser.RULE_stmt_if); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10078; + this.match(PostgreSQLParser.IF_P); + this.state = 10079; + this.expr_until_then(); + this.state = 10080; + this.match(PostgreSQLParser.THEN); + this.state = 10081; + this.proc_sect(); + this.state = 10082; + this.stmt_elsifs(); + this.state = 10083; + this.stmt_else(); + this.state = 10084; + this.match(PostgreSQLParser.END_P); + this.state = 10085; + this.match(PostgreSQLParser.IF_P); + this.state = 10086; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_elsifsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_elsifs; + return this; +} + +Stmt_elsifsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_elsifsContext.prototype.constructor = Stmt_elsifsContext; + +Stmt_elsifsContext.prototype.ELSIF = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.ELSIF); + } else { + return this.getToken(PostgreSQLParser.ELSIF, i); + } +}; + + +Stmt_elsifsContext.prototype.a_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_exprContext); + } else { + return this.getTypedRuleContext(A_exprContext,i); + } +}; + +Stmt_elsifsContext.prototype.THEN = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.THEN); + } else { + return this.getToken(PostgreSQLParser.THEN, i); + } +}; + + +Stmt_elsifsContext.prototype.proc_sect = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Proc_sectContext); + } else { + return this.getTypedRuleContext(Proc_sectContext,i); + } +}; + +Stmt_elsifsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_elsifs(this); + } +}; + +Stmt_elsifsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_elsifs(this); + } +}; + +Stmt_elsifsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_elsifs(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_elsifsContext = Stmt_elsifsContext; + +PostgreSQLParser.prototype.stmt_elsifs = function() { + + var localctx = new Stmt_elsifsContext(this, this._ctx, this.state); + this.enterRule(localctx, 1464, PostgreSQLParser.RULE_stmt_elsifs); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10095; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.ELSIF) { + this.state = 10088; + this.match(PostgreSQLParser.ELSIF); + this.state = 10089; + this.a_expr(); + this.state = 10090; + this.match(PostgreSQLParser.THEN); + this.state = 10091; + this.proc_sect(); + this.state = 10097; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_elseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_else; + return this; +} + +Stmt_elseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_elseContext.prototype.constructor = Stmt_elseContext; + +Stmt_elseContext.prototype.ELSE = function() { + return this.getToken(PostgreSQLParser.ELSE, 0); +}; + +Stmt_elseContext.prototype.proc_sect = function() { + return this.getTypedRuleContext(Proc_sectContext,0); +}; + +Stmt_elseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_else(this); + } +}; + +Stmt_elseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_else(this); + } +}; + +Stmt_elseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_else(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_elseContext = Stmt_elseContext; + +PostgreSQLParser.prototype.stmt_else = function() { + + var localctx = new Stmt_elseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1466, PostgreSQLParser.RULE_stmt_else); + try { + this.state = 10101; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.END_P: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.ELSE: + this.enterOuterAlt(localctx, 2); + this.state = 10099; + this.match(PostgreSQLParser.ELSE); + this.state = 10100; + this.proc_sect(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_caseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_case; + return this; +} + +Stmt_caseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_caseContext.prototype.constructor = Stmt_caseContext; + +Stmt_caseContext.prototype.CASE = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.CASE); + } else { + return this.getToken(PostgreSQLParser.CASE, i); + } +}; + + +Stmt_caseContext.prototype.opt_expr_until_when = function() { + return this.getTypedRuleContext(Opt_expr_until_whenContext,0); +}; + +Stmt_caseContext.prototype.case_when_list = function() { + return this.getTypedRuleContext(Case_when_listContext,0); +}; + +Stmt_caseContext.prototype.opt_case_else = function() { + return this.getTypedRuleContext(Opt_case_elseContext,0); +}; + +Stmt_caseContext.prototype.END_P = function() { + return this.getToken(PostgreSQLParser.END_P, 0); +}; + +Stmt_caseContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_caseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_case(this); + } +}; + +Stmt_caseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_case(this); + } +}; + +Stmt_caseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_case(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_caseContext = Stmt_caseContext; + +PostgreSQLParser.prototype.stmt_case = function() { + + var localctx = new Stmt_caseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1468, PostgreSQLParser.RULE_stmt_case); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10103; + this.match(PostgreSQLParser.CASE); + this.state = 10104; + this.opt_expr_until_when(); + this.state = 10105; + this.case_when_list(); + this.state = 10106; + this.opt_case_else(); + this.state = 10107; + this.match(PostgreSQLParser.END_P); + this.state = 10108; + this.match(PostgreSQLParser.CASE); + this.state = 10109; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_expr_until_whenContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_expr_until_when; + return this; +} + +Opt_expr_until_whenContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_expr_until_whenContext.prototype.constructor = Opt_expr_until_whenContext; + +Opt_expr_until_whenContext.prototype.sql_expression = function() { + return this.getTypedRuleContext(Sql_expressionContext,0); +}; + +Opt_expr_until_whenContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_expr_until_when(this); + } +}; + +Opt_expr_until_whenContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_expr_until_when(this); + } +}; + +Opt_expr_until_whenContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_expr_until_when(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_expr_until_whenContext = Opt_expr_until_whenContext; + +PostgreSQLParser.prototype.opt_expr_until_when = function() { + + var localctx = new Opt_expr_until_whenContext(this, this._ctx, this.state); + this.enterRule(localctx, 1470, PostgreSQLParser.RULE_opt_expr_until_when); + try { + this.state = 10113; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,671,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 10112; + this.sql_expression(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Case_when_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_case_when_list; + return this; +} + +Case_when_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Case_when_listContext.prototype.constructor = Case_when_listContext; + +Case_when_listContext.prototype.case_when = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Case_whenContext); + } else { + return this.getTypedRuleContext(Case_whenContext,i); + } +}; + +Case_when_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCase_when_list(this); + } +}; + +Case_when_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCase_when_list(this); + } +}; + +Case_when_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCase_when_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Case_when_listContext = Case_when_listContext; + +PostgreSQLParser.prototype.case_when_list = function() { + + var localctx = new Case_when_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1472, PostgreSQLParser.RULE_case_when_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10116; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + this.state = 10115; + this.case_when(); + this.state = 10118; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while(_la===PostgreSQLParser.WHEN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Case_whenContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_case_when; + return this; +} + +Case_whenContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Case_whenContext.prototype.constructor = Case_whenContext; + +Case_whenContext.prototype.WHEN = function() { + return this.getToken(PostgreSQLParser.WHEN, 0); +}; + +Case_whenContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Case_whenContext.prototype.THEN = function() { + return this.getToken(PostgreSQLParser.THEN, 0); +}; + +Case_whenContext.prototype.proc_sect = function() { + return this.getTypedRuleContext(Proc_sectContext,0); +}; + +Case_whenContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCase_when(this); + } +}; + +Case_whenContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCase_when(this); + } +}; + +Case_whenContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCase_when(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Case_whenContext = Case_whenContext; + +PostgreSQLParser.prototype.case_when = function() { + + var localctx = new Case_whenContext(this, this._ctx, this.state); + this.enterRule(localctx, 1474, PostgreSQLParser.RULE_case_when); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10120; + this.match(PostgreSQLParser.WHEN); + this.state = 10121; + this.expr_list(); + this.state = 10122; + this.match(PostgreSQLParser.THEN); + this.state = 10123; + this.proc_sect(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_case_elseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_case_else; + return this; +} + +Opt_case_elseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_case_elseContext.prototype.constructor = Opt_case_elseContext; + +Opt_case_elseContext.prototype.ELSE = function() { + return this.getToken(PostgreSQLParser.ELSE, 0); +}; + +Opt_case_elseContext.prototype.proc_sect = function() { + return this.getTypedRuleContext(Proc_sectContext,0); +}; + +Opt_case_elseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_case_else(this); + } +}; + +Opt_case_elseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_case_else(this); + } +}; + +Opt_case_elseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_case_else(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_case_elseContext = Opt_case_elseContext; + +PostgreSQLParser.prototype.opt_case_else = function() { + + var localctx = new Opt_case_elseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1476, PostgreSQLParser.RULE_opt_case_else); + try { + this.state = 10128; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.END_P: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.ELSE: + this.enterOuterAlt(localctx, 2); + this.state = 10126; + this.match(PostgreSQLParser.ELSE); + this.state = 10127; + this.proc_sect(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_loopContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_loop; + return this; +} + +Stmt_loopContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_loopContext.prototype.constructor = Stmt_loopContext; + +Stmt_loopContext.prototype.opt_loop_label = function() { + return this.getTypedRuleContext(Opt_loop_labelContext,0); +}; + +Stmt_loopContext.prototype.loop_body = function() { + return this.getTypedRuleContext(Loop_bodyContext,0); +}; + +Stmt_loopContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_loop(this); + } +}; + +Stmt_loopContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_loop(this); + } +}; + +Stmt_loopContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_loop(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_loopContext = Stmt_loopContext; + +PostgreSQLParser.prototype.stmt_loop = function() { + + var localctx = new Stmt_loopContext(this, this._ctx, this.state); + this.enterRule(localctx, 1478, PostgreSQLParser.RULE_stmt_loop); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10130; + this.opt_loop_label(); + this.state = 10131; + this.loop_body(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_whileContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_while; + return this; +} + +Stmt_whileContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_whileContext.prototype.constructor = Stmt_whileContext; + +Stmt_whileContext.prototype.opt_loop_label = function() { + return this.getTypedRuleContext(Opt_loop_labelContext,0); +}; + +Stmt_whileContext.prototype.WHILE = function() { + return this.getToken(PostgreSQLParser.WHILE, 0); +}; + +Stmt_whileContext.prototype.expr_until_loop = function() { + return this.getTypedRuleContext(Expr_until_loopContext,0); +}; + +Stmt_whileContext.prototype.loop_body = function() { + return this.getTypedRuleContext(Loop_bodyContext,0); +}; + +Stmt_whileContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_while(this); + } +}; + +Stmt_whileContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_while(this); + } +}; + +Stmt_whileContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_while(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_whileContext = Stmt_whileContext; + +PostgreSQLParser.prototype.stmt_while = function() { + + var localctx = new Stmt_whileContext(this, this._ctx, this.state); + this.enterRule(localctx, 1480, PostgreSQLParser.RULE_stmt_while); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10133; + this.opt_loop_label(); + this.state = 10134; + this.match(PostgreSQLParser.WHILE); + this.state = 10135; + this.expr_until_loop(); + this.state = 10136; + this.loop_body(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_forContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_for; + return this; +} + +Stmt_forContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_forContext.prototype.constructor = Stmt_forContext; + +Stmt_forContext.prototype.opt_loop_label = function() { + return this.getTypedRuleContext(Opt_loop_labelContext,0); +}; + +Stmt_forContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Stmt_forContext.prototype.for_control = function() { + return this.getTypedRuleContext(For_controlContext,0); +}; + +Stmt_forContext.prototype.loop_body = function() { + return this.getTypedRuleContext(Loop_bodyContext,0); +}; + +Stmt_forContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_for(this); + } +}; + +Stmt_forContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_for(this); + } +}; + +Stmt_forContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_for(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_forContext = Stmt_forContext; + +PostgreSQLParser.prototype.stmt_for = function() { + + var localctx = new Stmt_forContext(this, this._ctx, this.state); + this.enterRule(localctx, 1482, PostgreSQLParser.RULE_stmt_for); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10138; + this.opt_loop_label(); + this.state = 10139; + this.match(PostgreSQLParser.FOR); + this.state = 10140; + this.for_control(); + this.state = 10141; + this.loop_body(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function For_controlContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_for_control; + return this; +} + +For_controlContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +For_controlContext.prototype.constructor = For_controlContext; + +For_controlContext.prototype.for_variable = function() { + return this.getTypedRuleContext(For_variableContext,0); +}; + +For_controlContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +For_controlContext.prototype.cursor_name = function() { + return this.getTypedRuleContext(Cursor_nameContext,0); +}; + +For_controlContext.prototype.opt_cursor_parameters = function() { + return this.getTypedRuleContext(Opt_cursor_parametersContext,0); +}; + +For_controlContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +For_controlContext.prototype.explainstmt = function() { + return this.getTypedRuleContext(ExplainstmtContext,0); +}; + +For_controlContext.prototype.EXECUTE = function() { + return this.getToken(PostgreSQLParser.EXECUTE, 0); +}; + +For_controlContext.prototype.a_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_exprContext); + } else { + return this.getTypedRuleContext(A_exprContext,i); + } +}; + +For_controlContext.prototype.opt_for_using_expression = function() { + return this.getTypedRuleContext(Opt_for_using_expressionContext,0); +}; + +For_controlContext.prototype.opt_reverse = function() { + return this.getTypedRuleContext(Opt_reverseContext,0); +}; + +For_controlContext.prototype.DOT_DOT = function() { + return this.getToken(PostgreSQLParser.DOT_DOT, 0); +}; + +For_controlContext.prototype.opt_by_expression = function() { + return this.getTypedRuleContext(Opt_by_expressionContext,0); +}; + +For_controlContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFor_control(this); + } +}; + +For_controlContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFor_control(this); + } +}; + +For_controlContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFor_control(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.For_controlContext = For_controlContext; + +PostgreSQLParser.prototype.for_control = function() { + + var localctx = new For_controlContext(this, this._ctx, this.state); + this.enterRule(localctx, 1484, PostgreSQLParser.RULE_for_control); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10143; + this.for_variable(); + this.state = 10144; + this.match(PostgreSQLParser.IN_P); + this.state = 10160; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,674,this._ctx); + switch(la_) { + case 1: + this.state = 10145; + this.cursor_name(); + this.state = 10146; + this.opt_cursor_parameters(); + break; + + case 2: + this.state = 10148; + this.selectstmt(); + break; + + case 3: + this.state = 10149; + this.explainstmt(); + break; + + case 4: + this.state = 10150; + this.match(PostgreSQLParser.EXECUTE); + this.state = 10151; + this.a_expr(); + this.state = 10152; + this.opt_for_using_expression(); + break; + + case 5: + this.state = 10154; + this.opt_reverse(); + this.state = 10155; + this.a_expr(); + this.state = 10156; + this.match(PostgreSQLParser.DOT_DOT); + this.state = 10157; + this.a_expr(); + this.state = 10158; + this.opt_by_expression(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_for_using_expressionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_for_using_expression; + return this; +} + +Opt_for_using_expressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_for_using_expressionContext.prototype.constructor = Opt_for_using_expressionContext; + +Opt_for_using_expressionContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Opt_for_using_expressionContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Opt_for_using_expressionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_for_using_expression(this); + } +}; + +Opt_for_using_expressionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_for_using_expression(this); + } +}; + +Opt_for_using_expressionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_for_using_expression(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_for_using_expressionContext = Opt_for_using_expressionContext; + +PostgreSQLParser.prototype.opt_for_using_expression = function() { + + var localctx = new Opt_for_using_expressionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1486, PostgreSQLParser.RULE_opt_for_using_expression); + try { + this.state = 10165; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SEMI: + case PostgreSQLParser.LOOP: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 2); + this.state = 10163; + this.match(PostgreSQLParser.USING); + this.state = 10164; + this.expr_list(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_cursor_parametersContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_cursor_parameters; + return this; +} + +Opt_cursor_parametersContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_cursor_parametersContext.prototype.constructor = Opt_cursor_parametersContext; + +Opt_cursor_parametersContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Opt_cursor_parametersContext.prototype.a_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_exprContext); + } else { + return this.getTypedRuleContext(A_exprContext,i); + } +}; + +Opt_cursor_parametersContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Opt_cursor_parametersContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Opt_cursor_parametersContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_cursor_parameters(this); + } +}; + +Opt_cursor_parametersContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_cursor_parameters(this); + } +}; + +Opt_cursor_parametersContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_cursor_parameters(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_cursor_parametersContext = Opt_cursor_parametersContext; + +PostgreSQLParser.prototype.opt_cursor_parameters = function() { + + var localctx = new Opt_cursor_parametersContext(this, this._ctx, this.state); + this.enterRule(localctx, 1488, PostgreSQLParser.RULE_opt_cursor_parameters); + var _la = 0; // Token type + try { + this.state = 10179; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.LOOP: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.OPEN_PAREN: + this.enterOuterAlt(localctx, 2); + this.state = 10168; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 10169; + this.a_expr(); + this.state = 10174; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 10170; + this.match(PostgreSQLParser.COMMA); + this.state = 10171; + this.a_expr(); + this.state = 10176; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 10177; + this.match(PostgreSQLParser.CLOSE_PAREN); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_reverseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_reverse; + return this; +} + +Opt_reverseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_reverseContext.prototype.constructor = Opt_reverseContext; + +Opt_reverseContext.prototype.REVERSE = function() { + return this.getToken(PostgreSQLParser.REVERSE, 0); +}; + +Opt_reverseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_reverse(this); + } +}; + +Opt_reverseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_reverse(this); + } +}; + +Opt_reverseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_reverse(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_reverseContext = Opt_reverseContext; + +PostgreSQLParser.prototype.opt_reverse = function() { + + var localctx = new Opt_reverseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1490, PostgreSQLParser.RULE_opt_reverse); + try { + this.state = 10183; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,678,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 10182; + this.match(PostgreSQLParser.REVERSE); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_by_expressionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_by_expression; + return this; +} + +Opt_by_expressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_by_expressionContext.prototype.constructor = Opt_by_expressionContext; + +Opt_by_expressionContext.prototype.BY = function() { + return this.getToken(PostgreSQLParser.BY, 0); +}; + +Opt_by_expressionContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Opt_by_expressionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_by_expression(this); + } +}; + +Opt_by_expressionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_by_expression(this); + } +}; + +Opt_by_expressionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_by_expression(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_by_expressionContext = Opt_by_expressionContext; + +PostgreSQLParser.prototype.opt_by_expression = function() { + + var localctx = new Opt_by_expressionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1492, PostgreSQLParser.RULE_opt_by_expression); + try { + this.state = 10188; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.LOOP: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.BY: + this.enterOuterAlt(localctx, 2); + this.state = 10186; + this.match(PostgreSQLParser.BY); + this.state = 10187; + this.a_expr(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function For_variableContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_for_variable; + return this; +} + +For_variableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +For_variableContext.prototype.constructor = For_variableContext; + +For_variableContext.prototype.any_name_list = function() { + return this.getTypedRuleContext(Any_name_listContext,0); +}; + +For_variableContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterFor_variable(this); + } +}; + +For_variableContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitFor_variable(this); + } +}; + +For_variableContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitFor_variable(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.For_variableContext = For_variableContext; + +PostgreSQLParser.prototype.for_variable = function() { + + var localctx = new For_variableContext(this, this._ctx, this.state); + this.enterRule(localctx, 1494, PostgreSQLParser.RULE_for_variable); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10190; + this.any_name_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_foreach_aContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_foreach_a; + return this; +} + +Stmt_foreach_aContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_foreach_aContext.prototype.constructor = Stmt_foreach_aContext; + +Stmt_foreach_aContext.prototype.opt_loop_label = function() { + return this.getTypedRuleContext(Opt_loop_labelContext,0); +}; + +Stmt_foreach_aContext.prototype.FOREACH = function() { + return this.getToken(PostgreSQLParser.FOREACH, 0); +}; + +Stmt_foreach_aContext.prototype.for_variable = function() { + return this.getTypedRuleContext(For_variableContext,0); +}; + +Stmt_foreach_aContext.prototype.foreach_slice = function() { + return this.getTypedRuleContext(Foreach_sliceContext,0); +}; + +Stmt_foreach_aContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +Stmt_foreach_aContext.prototype.ARRAY = function() { + return this.getToken(PostgreSQLParser.ARRAY, 0); +}; + +Stmt_foreach_aContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Stmt_foreach_aContext.prototype.loop_body = function() { + return this.getTypedRuleContext(Loop_bodyContext,0); +}; + +Stmt_foreach_aContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_foreach_a(this); + } +}; + +Stmt_foreach_aContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_foreach_a(this); + } +}; + +Stmt_foreach_aContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_foreach_a(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_foreach_aContext = Stmt_foreach_aContext; + +PostgreSQLParser.prototype.stmt_foreach_a = function() { + + var localctx = new Stmt_foreach_aContext(this, this._ctx, this.state); + this.enterRule(localctx, 1496, PostgreSQLParser.RULE_stmt_foreach_a); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10192; + this.opt_loop_label(); + this.state = 10193; + this.match(PostgreSQLParser.FOREACH); + this.state = 10194; + this.for_variable(); + this.state = 10195; + this.foreach_slice(); + this.state = 10196; + this.match(PostgreSQLParser.IN_P); + this.state = 10197; + this.match(PostgreSQLParser.ARRAY); + this.state = 10198; + this.a_expr(); + this.state = 10199; + this.loop_body(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Foreach_sliceContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_foreach_slice; + return this; +} + +Foreach_sliceContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Foreach_sliceContext.prototype.constructor = Foreach_sliceContext; + +Foreach_sliceContext.prototype.SLICE = function() { + return this.getToken(PostgreSQLParser.SLICE, 0); +}; + +Foreach_sliceContext.prototype.iconst = function() { + return this.getTypedRuleContext(IconstContext,0); +}; + +Foreach_sliceContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterForeach_slice(this); + } +}; + +Foreach_sliceContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitForeach_slice(this); + } +}; + +Foreach_sliceContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitForeach_slice(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Foreach_sliceContext = Foreach_sliceContext; + +PostgreSQLParser.prototype.foreach_slice = function() { + + var localctx = new Foreach_sliceContext(this, this._ctx, this.state); + this.enterRule(localctx, 1498, PostgreSQLParser.RULE_foreach_slice); + try { + this.state = 10204; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.IN_P: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.SLICE: + this.enterOuterAlt(localctx, 2); + this.state = 10202; + this.match(PostgreSQLParser.SLICE); + this.state = 10203; + this.iconst(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_exitContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_exit; + return this; +} + +Stmt_exitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_exitContext.prototype.constructor = Stmt_exitContext; + +Stmt_exitContext.prototype.exit_type = function() { + return this.getTypedRuleContext(Exit_typeContext,0); +}; + +Stmt_exitContext.prototype.opt_label = function() { + return this.getTypedRuleContext(Opt_labelContext,0); +}; + +Stmt_exitContext.prototype.opt_exitcond = function() { + return this.getTypedRuleContext(Opt_exitcondContext,0); +}; + +Stmt_exitContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_exitContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_exit(this); + } +}; + +Stmt_exitContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_exit(this); + } +}; + +Stmt_exitContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_exit(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_exitContext = Stmt_exitContext; + +PostgreSQLParser.prototype.stmt_exit = function() { + + var localctx = new Stmt_exitContext(this, this._ctx, this.state); + this.enterRule(localctx, 1500, PostgreSQLParser.RULE_stmt_exit); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10206; + this.exit_type(); + this.state = 10207; + this.opt_label(); + this.state = 10208; + this.opt_exitcond(); + this.state = 10209; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Exit_typeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_exit_type; + return this; +} + +Exit_typeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Exit_typeContext.prototype.constructor = Exit_typeContext; + +Exit_typeContext.prototype.EXIT = function() { + return this.getToken(PostgreSQLParser.EXIT, 0); +}; + +Exit_typeContext.prototype.CONTINUE_P = function() { + return this.getToken(PostgreSQLParser.CONTINUE_P, 0); +}; + +Exit_typeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExit_type(this); + } +}; + +Exit_typeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExit_type(this); + } +}; + +Exit_typeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExit_type(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Exit_typeContext = Exit_typeContext; + +PostgreSQLParser.prototype.exit_type = function() { + + var localctx = new Exit_typeContext(this, this._ctx, this.state); + this.enterRule(localctx, 1502, PostgreSQLParser.RULE_exit_type); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10211; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.CONTINUE_P || _la===PostgreSQLParser.EXIT)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_returnContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_return; + return this; +} + +Stmt_returnContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_returnContext.prototype.constructor = Stmt_returnContext; + +Stmt_returnContext.prototype.RETURN = function() { + return this.getToken(PostgreSQLParser.RETURN, 0); +}; + +Stmt_returnContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_returnContext.prototype.NEXT = function() { + return this.getToken(PostgreSQLParser.NEXT, 0); +}; + +Stmt_returnContext.prototype.sql_expression = function() { + return this.getTypedRuleContext(Sql_expressionContext,0); +}; + +Stmt_returnContext.prototype.QUERY = function() { + return this.getToken(PostgreSQLParser.QUERY, 0); +}; + +Stmt_returnContext.prototype.opt_return_result = function() { + return this.getTypedRuleContext(Opt_return_resultContext,0); +}; + +Stmt_returnContext.prototype.EXECUTE = function() { + return this.getToken(PostgreSQLParser.EXECUTE, 0); +}; + +Stmt_returnContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Stmt_returnContext.prototype.opt_for_using_expression = function() { + return this.getTypedRuleContext(Opt_for_using_expressionContext,0); +}; + +Stmt_returnContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +Stmt_returnContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_return(this); + } +}; + +Stmt_returnContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_return(this); + } +}; + +Stmt_returnContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_return(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_returnContext = Stmt_returnContext; + +PostgreSQLParser.prototype.stmt_return = function() { + + var localctx = new Stmt_returnContext(this, this._ctx, this.state); + this.enterRule(localctx, 1504, PostgreSQLParser.RULE_stmt_return); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10213; + this.match(PostgreSQLParser.RETURN); + this.state = 10225; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,682,this._ctx); + switch(la_) { + case 1: + this.state = 10214; + this.match(PostgreSQLParser.NEXT); + this.state = 10215; + this.sql_expression(); + break; + + case 2: + this.state = 10216; + this.match(PostgreSQLParser.QUERY); + this.state = 10222; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.EXECUTE: + this.state = 10217; + this.match(PostgreSQLParser.EXECUTE); + this.state = 10218; + this.a_expr(); + this.state = 10219; + this.opt_for_using_expression(); + break; + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.VALUES: + this.state = 10221; + this.selectstmt(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 3: + this.state = 10224; + this.opt_return_result(); + break; + + } + this.state = 10227; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_return_resultContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_return_result; + return this; +} + +Opt_return_resultContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_return_resultContext.prototype.constructor = Opt_return_resultContext; + +Opt_return_resultContext.prototype.sql_expression = function() { + return this.getTypedRuleContext(Sql_expressionContext,0); +}; + +Opt_return_resultContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_return_result(this); + } +}; + +Opt_return_resultContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_return_result(this); + } +}; + +Opt_return_resultContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_return_result(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_return_resultContext = Opt_return_resultContext; + +PostgreSQLParser.prototype.opt_return_result = function() { + + var localctx = new Opt_return_resultContext(this, this._ctx, this.state); + this.enterRule(localctx, 1506, PostgreSQLParser.RULE_opt_return_result); + try { + this.state = 10231; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,683,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 10230; + this.sql_expression(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_raiseContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_raise; + return this; +} + +Stmt_raiseContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_raiseContext.prototype.constructor = Stmt_raiseContext; + +Stmt_raiseContext.prototype.RAISE = function() { + return this.getToken(PostgreSQLParser.RAISE, 0); +}; + +Stmt_raiseContext.prototype.opt_stmt_raise_level = function() { + return this.getTypedRuleContext(Opt_stmt_raise_levelContext,0); +}; + +Stmt_raiseContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Stmt_raiseContext.prototype.opt_raise_list = function() { + return this.getTypedRuleContext(Opt_raise_listContext,0); +}; + +Stmt_raiseContext.prototype.opt_raise_using = function() { + return this.getTypedRuleContext(Opt_raise_usingContext,0); +}; + +Stmt_raiseContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_raiseContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +Stmt_raiseContext.prototype.SQLSTATE = function() { + return this.getToken(PostgreSQLParser.SQLSTATE, 0); +}; + +Stmt_raiseContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_raise(this); + } +}; + +Stmt_raiseContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_raise(this); + } +}; + +Stmt_raiseContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_raise(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_raiseContext = Stmt_raiseContext; + +PostgreSQLParser.prototype.stmt_raise = function() { + + var localctx = new Stmt_raiseContext(this, this._ctx, this.state); + this.enterRule(localctx, 1508, PostgreSQLParser.RULE_stmt_raise); + try { + this.state = 10259; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,684,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 10233; + this.match(PostgreSQLParser.RAISE); + this.state = 10234; + this.opt_stmt_raise_level(); + this.state = 10235; + this.sconst(); + this.state = 10236; + this.opt_raise_list(); + this.state = 10237; + this.opt_raise_using(); + this.state = 10238; + this.match(PostgreSQLParser.SEMI); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 10240; + this.match(PostgreSQLParser.RAISE); + this.state = 10241; + this.opt_stmt_raise_level(); + this.state = 10242; + this.identifier(); + this.state = 10243; + this.opt_raise_using(); + this.state = 10244; + this.match(PostgreSQLParser.SEMI); + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 10246; + this.match(PostgreSQLParser.RAISE); + this.state = 10247; + this.opt_stmt_raise_level(); + this.state = 10248; + this.match(PostgreSQLParser.SQLSTATE); + this.state = 10249; + this.sconst(); + this.state = 10250; + this.opt_raise_using(); + this.state = 10251; + this.match(PostgreSQLParser.SEMI); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 10253; + this.match(PostgreSQLParser.RAISE); + this.state = 10254; + this.opt_stmt_raise_level(); + this.state = 10255; + this.opt_raise_using(); + this.state = 10256; + this.match(PostgreSQLParser.SEMI); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 10258; + this.match(PostgreSQLParser.RAISE); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_stmt_raise_levelContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_stmt_raise_level; + return this; +} + +Opt_stmt_raise_levelContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_stmt_raise_levelContext.prototype.constructor = Opt_stmt_raise_levelContext; + +Opt_stmt_raise_levelContext.prototype.DEBUG = function() { + return this.getToken(PostgreSQLParser.DEBUG, 0); +}; + +Opt_stmt_raise_levelContext.prototype.LOG = function() { + return this.getToken(PostgreSQLParser.LOG, 0); +}; + +Opt_stmt_raise_levelContext.prototype.INFO = function() { + return this.getToken(PostgreSQLParser.INFO, 0); +}; + +Opt_stmt_raise_levelContext.prototype.NOTICE = function() { + return this.getToken(PostgreSQLParser.NOTICE, 0); +}; + +Opt_stmt_raise_levelContext.prototype.WARNING = function() { + return this.getToken(PostgreSQLParser.WARNING, 0); +}; + +Opt_stmt_raise_levelContext.prototype.EXCEPTION = function() { + return this.getToken(PostgreSQLParser.EXCEPTION, 0); +}; + +Opt_stmt_raise_levelContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_stmt_raise_level(this); + } +}; + +Opt_stmt_raise_levelContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_stmt_raise_level(this); + } +}; + +Opt_stmt_raise_levelContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_stmt_raise_level(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_stmt_raise_levelContext = Opt_stmt_raise_levelContext; + +PostgreSQLParser.prototype.opt_stmt_raise_level = function() { + + var localctx = new Opt_stmt_raise_levelContext(this, this._ctx, this.state); + this.enterRule(localctx, 1510, PostgreSQLParser.RULE_opt_stmt_raise_level); + try { + this.state = 10269; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,685,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 10263; + this.match(PostgreSQLParser.DEBUG); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 10264; + this.match(PostgreSQLParser.LOG); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 10265; + this.match(PostgreSQLParser.INFO); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 10266; + this.match(PostgreSQLParser.NOTICE); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 10267; + this.match(PostgreSQLParser.WARNING); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 10268; + this.match(PostgreSQLParser.EXCEPTION); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_raise_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_raise_list; + return this; +} + +Opt_raise_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_raise_listContext.prototype.constructor = Opt_raise_listContext; + +Opt_raise_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Opt_raise_listContext.prototype.a_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_exprContext); + } else { + return this.getTypedRuleContext(A_exprContext,i); + } +}; + +Opt_raise_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_raise_list(this); + } +}; + +Opt_raise_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_raise_list(this); + } +}; + +Opt_raise_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_raise_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_raise_listContext = Opt_raise_listContext; + +PostgreSQLParser.prototype.opt_raise_list = function() { + + var localctx = new Opt_raise_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1512, PostgreSQLParser.RULE_opt_raise_list); + var _la = 0; // Token type + try { + this.state = 10278; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SEMI: + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.COMMA: + this.enterOuterAlt(localctx, 2); + this.state = 10274; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + this.state = 10272; + this.match(PostgreSQLParser.COMMA); + this.state = 10273; + this.a_expr(); + this.state = 10276; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while(_la===PostgreSQLParser.COMMA); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_raise_usingContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_raise_using; + return this; +} + +Opt_raise_usingContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_raise_usingContext.prototype.constructor = Opt_raise_usingContext; + +Opt_raise_usingContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Opt_raise_usingContext.prototype.opt_raise_using_elem_list = function() { + return this.getTypedRuleContext(Opt_raise_using_elem_listContext,0); +}; + +Opt_raise_usingContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_raise_using(this); + } +}; + +Opt_raise_usingContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_raise_using(this); + } +}; + +Opt_raise_usingContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_raise_using(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_raise_usingContext = Opt_raise_usingContext; + +PostgreSQLParser.prototype.opt_raise_using = function() { + + var localctx = new Opt_raise_usingContext(this, this._ctx, this.state); + this.enterRule(localctx, 1514, PostgreSQLParser.RULE_opt_raise_using); + try { + this.state = 10283; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SEMI: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 2); + this.state = 10281; + this.match(PostgreSQLParser.USING); + this.state = 10282; + this.opt_raise_using_elem_list(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_raise_using_elemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_raise_using_elem; + return this; +} + +Opt_raise_using_elemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_raise_using_elemContext.prototype.constructor = Opt_raise_using_elemContext; + +Opt_raise_using_elemContext.prototype.identifier = function() { + return this.getTypedRuleContext(IdentifierContext,0); +}; + +Opt_raise_using_elemContext.prototype.EQUAL = function() { + return this.getToken(PostgreSQLParser.EQUAL, 0); +}; + +Opt_raise_using_elemContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Opt_raise_using_elemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_raise_using_elem(this); + } +}; + +Opt_raise_using_elemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_raise_using_elem(this); + } +}; + +Opt_raise_using_elemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_raise_using_elem(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_raise_using_elemContext = Opt_raise_using_elemContext; + +PostgreSQLParser.prototype.opt_raise_using_elem = function() { + + var localctx = new Opt_raise_using_elemContext(this, this._ctx, this.state); + this.enterRule(localctx, 1516, PostgreSQLParser.RULE_opt_raise_using_elem); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10285; + this.identifier(); + this.state = 10286; + this.match(PostgreSQLParser.EQUAL); + this.state = 10287; + this.a_expr(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_raise_using_elem_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_raise_using_elem_list; + return this; +} + +Opt_raise_using_elem_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_raise_using_elem_listContext.prototype.constructor = Opt_raise_using_elem_listContext; + +Opt_raise_using_elem_listContext.prototype.opt_raise_using_elem = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Opt_raise_using_elemContext); + } else { + return this.getTypedRuleContext(Opt_raise_using_elemContext,i); + } +}; + +Opt_raise_using_elem_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Opt_raise_using_elem_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_raise_using_elem_list(this); + } +}; + +Opt_raise_using_elem_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_raise_using_elem_list(this); + } +}; + +Opt_raise_using_elem_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_raise_using_elem_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_raise_using_elem_listContext = Opt_raise_using_elem_listContext; + +PostgreSQLParser.prototype.opt_raise_using_elem_list = function() { + + var localctx = new Opt_raise_using_elem_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1518, PostgreSQLParser.RULE_opt_raise_using_elem_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10289; + this.opt_raise_using_elem(); + this.state = 10294; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 10290; + this.match(PostgreSQLParser.COMMA); + this.state = 10291; + this.opt_raise_using_elem(); + this.state = 10296; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_assertContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_assert; + return this; +} + +Stmt_assertContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_assertContext.prototype.constructor = Stmt_assertContext; + +Stmt_assertContext.prototype.ASSERT = function() { + return this.getToken(PostgreSQLParser.ASSERT, 0); +}; + +Stmt_assertContext.prototype.sql_expression = function() { + return this.getTypedRuleContext(Sql_expressionContext,0); +}; + +Stmt_assertContext.prototype.opt_stmt_assert_message = function() { + return this.getTypedRuleContext(Opt_stmt_assert_messageContext,0); +}; + +Stmt_assertContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_assertContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_assert(this); + } +}; + +Stmt_assertContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_assert(this); + } +}; + +Stmt_assertContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_assert(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_assertContext = Stmt_assertContext; + +PostgreSQLParser.prototype.stmt_assert = function() { + + var localctx = new Stmt_assertContext(this, this._ctx, this.state); + this.enterRule(localctx, 1520, PostgreSQLParser.RULE_stmt_assert); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10297; + this.match(PostgreSQLParser.ASSERT); + this.state = 10298; + this.sql_expression(); + this.state = 10299; + this.opt_stmt_assert_message(); + this.state = 10300; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_stmt_assert_messageContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_stmt_assert_message; + return this; +} + +Opt_stmt_assert_messageContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_stmt_assert_messageContext.prototype.constructor = Opt_stmt_assert_messageContext; + +Opt_stmt_assert_messageContext.prototype.COMMA = function() { + return this.getToken(PostgreSQLParser.COMMA, 0); +}; + +Opt_stmt_assert_messageContext.prototype.sql_expression = function() { + return this.getTypedRuleContext(Sql_expressionContext,0); +}; + +Opt_stmt_assert_messageContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_stmt_assert_message(this); + } +}; + +Opt_stmt_assert_messageContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_stmt_assert_message(this); + } +}; + +Opt_stmt_assert_messageContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_stmt_assert_message(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_stmt_assert_messageContext = Opt_stmt_assert_messageContext; + +PostgreSQLParser.prototype.opt_stmt_assert_message = function() { + + var localctx = new Opt_stmt_assert_messageContext(this, this._ctx, this.state); + this.enterRule(localctx, 1522, PostgreSQLParser.RULE_opt_stmt_assert_message); + try { + this.state = 10305; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SEMI: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.COMMA: + this.enterOuterAlt(localctx, 2); + this.state = 10303; + this.match(PostgreSQLParser.COMMA); + this.state = 10304; + this.sql_expression(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Loop_bodyContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_loop_body; + return this; +} + +Loop_bodyContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Loop_bodyContext.prototype.constructor = Loop_bodyContext; + +Loop_bodyContext.prototype.LOOP = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.LOOP); + } else { + return this.getToken(PostgreSQLParser.LOOP, i); + } +}; + + +Loop_bodyContext.prototype.proc_sect = function() { + return this.getTypedRuleContext(Proc_sectContext,0); +}; + +Loop_bodyContext.prototype.END_P = function() { + return this.getToken(PostgreSQLParser.END_P, 0); +}; + +Loop_bodyContext.prototype.opt_label = function() { + return this.getTypedRuleContext(Opt_labelContext,0); +}; + +Loop_bodyContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Loop_bodyContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterLoop_body(this); + } +}; + +Loop_bodyContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitLoop_body(this); + } +}; + +Loop_bodyContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitLoop_body(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Loop_bodyContext = Loop_bodyContext; + +PostgreSQLParser.prototype.loop_body = function() { + + var localctx = new Loop_bodyContext(this, this._ctx, this.state); + this.enterRule(localctx, 1524, PostgreSQLParser.RULE_loop_body); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10307; + this.match(PostgreSQLParser.LOOP); + this.state = 10308; + this.proc_sect(); + this.state = 10309; + this.match(PostgreSQLParser.END_P); + this.state = 10310; + this.match(PostgreSQLParser.LOOP); + this.state = 10311; + this.opt_label(); + this.state = 10312; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_execsqlContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_execsql; + return this; +} + +Stmt_execsqlContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_execsqlContext.prototype.constructor = Stmt_execsqlContext; + +Stmt_execsqlContext.prototype.make_execsql_stmt = function() { + return this.getTypedRuleContext(Make_execsql_stmtContext,0); +}; + +Stmt_execsqlContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_execsqlContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_execsql(this); + } +}; + +Stmt_execsqlContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_execsql(this); + } +}; + +Stmt_execsqlContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_execsql(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_execsqlContext = Stmt_execsqlContext; + +PostgreSQLParser.prototype.stmt_execsql = function() { + + var localctx = new Stmt_execsqlContext(this, this._ctx, this.state); + this.enterRule(localctx, 1526, PostgreSQLParser.RULE_stmt_execsql); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10314; + this.make_execsql_stmt(); + this.state = 10315; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_dynexecuteContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_dynexecute; + return this; +} + +Stmt_dynexecuteContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_dynexecuteContext.prototype.constructor = Stmt_dynexecuteContext; + +Stmt_dynexecuteContext.prototype.EXECUTE = function() { + return this.getToken(PostgreSQLParser.EXECUTE, 0); +}; + +Stmt_dynexecuteContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Stmt_dynexecuteContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_dynexecuteContext.prototype.opt_execute_into = function() { + return this.getTypedRuleContext(Opt_execute_intoContext,0); +}; + +Stmt_dynexecuteContext.prototype.opt_execute_using = function() { + return this.getTypedRuleContext(Opt_execute_usingContext,0); +}; + +Stmt_dynexecuteContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_dynexecute(this); + } +}; + +Stmt_dynexecuteContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_dynexecute(this); + } +}; + +Stmt_dynexecuteContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_dynexecute(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_dynexecuteContext = Stmt_dynexecuteContext; + +PostgreSQLParser.prototype.stmt_dynexecute = function() { + + var localctx = new Stmt_dynexecuteContext(this, this._ctx, this.state); + this.enterRule(localctx, 1528, PostgreSQLParser.RULE_stmt_dynexecute); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10317; + this.match(PostgreSQLParser.EXECUTE); + this.state = 10318; + this.a_expr(); + this.state = 10326; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,691,this._ctx); + switch(la_) { + case 1: + this.state = 10319; + this.opt_execute_into(); + this.state = 10320; + this.opt_execute_using(); + break; + + case 2: + this.state = 10322; + this.opt_execute_using(); + this.state = 10323; + this.opt_execute_into(); + break; + + case 3: + break; + + } + this.state = 10328; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_execute_usingContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_execute_using; + return this; +} + +Opt_execute_usingContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_execute_usingContext.prototype.constructor = Opt_execute_usingContext; + +Opt_execute_usingContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Opt_execute_usingContext.prototype.opt_execute_using_list = function() { + return this.getTypedRuleContext(Opt_execute_using_listContext,0); +}; + +Opt_execute_usingContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_execute_using(this); + } +}; + +Opt_execute_usingContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_execute_using(this); + } +}; + +Opt_execute_usingContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_execute_using(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_execute_usingContext = Opt_execute_usingContext; + +PostgreSQLParser.prototype.opt_execute_using = function() { + + var localctx = new Opt_execute_usingContext(this, this._ctx, this.state); + this.enterRule(localctx, 1530, PostgreSQLParser.RULE_opt_execute_using); + try { + this.state = 10333; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SEMI: + case PostgreSQLParser.INTO: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 2); + this.state = 10331; + this.match(PostgreSQLParser.USING); + this.state = 10332; + this.opt_execute_using_list(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_execute_using_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_execute_using_list; + return this; +} + +Opt_execute_using_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_execute_using_listContext.prototype.constructor = Opt_execute_using_listContext; + +Opt_execute_using_listContext.prototype.a_expr = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(A_exprContext); + } else { + return this.getTypedRuleContext(A_exprContext,i); + } +}; + +Opt_execute_using_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Opt_execute_using_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_execute_using_list(this); + } +}; + +Opt_execute_using_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_execute_using_list(this); + } +}; + +Opt_execute_using_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_execute_using_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_execute_using_listContext = Opt_execute_using_listContext; + +PostgreSQLParser.prototype.opt_execute_using_list = function() { + + var localctx = new Opt_execute_using_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1532, PostgreSQLParser.RULE_opt_execute_using_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10335; + this.a_expr(); + this.state = 10340; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 10336; + this.match(PostgreSQLParser.COMMA); + this.state = 10337; + this.a_expr(); + this.state = 10342; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_execute_intoContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_execute_into; + return this; +} + +Opt_execute_intoContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_execute_intoContext.prototype.constructor = Opt_execute_intoContext; + +Opt_execute_intoContext.prototype.INTO = function() { + return this.getToken(PostgreSQLParser.INTO, 0); +}; + +Opt_execute_intoContext.prototype.into_target = function() { + return this.getTypedRuleContext(Into_targetContext,0); +}; + +Opt_execute_intoContext.prototype.STRICT_P = function() { + return this.getToken(PostgreSQLParser.STRICT_P, 0); +}; + +Opt_execute_intoContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_execute_into(this); + } +}; + +Opt_execute_intoContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_execute_into(this); + } +}; + +Opt_execute_intoContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_execute_into(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_execute_intoContext = Opt_execute_intoContext; + +PostgreSQLParser.prototype.opt_execute_into = function() { + + var localctx = new Opt_execute_intoContext(this, this._ctx, this.state); + this.enterRule(localctx, 1534, PostgreSQLParser.RULE_opt_execute_into); + try { + this.state = 10349; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SEMI: + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.INTO: + this.enterOuterAlt(localctx, 2); + this.state = 10344; + this.match(PostgreSQLParser.INTO); + this.state = 10346; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,694,this._ctx); + if(la_===1) { + this.state = 10345; + this.match(PostgreSQLParser.STRICT_P); + + } + this.state = 10348; + this.into_target(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_openContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_open; + return this; +} + +Stmt_openContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_openContext.prototype.constructor = Stmt_openContext; + +Stmt_openContext.prototype.OPEN = function() { + return this.getToken(PostgreSQLParser.OPEN, 0); +}; + +Stmt_openContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_openContext.prototype.cursor_variable = function() { + return this.getTypedRuleContext(Cursor_variableContext,0); +}; + +Stmt_openContext.prototype.opt_scroll_option = function() { + return this.getTypedRuleContext(Opt_scroll_optionContext,0); +}; + +Stmt_openContext.prototype.FOR = function() { + return this.getToken(PostgreSQLParser.FOR, 0); +}; + +Stmt_openContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Stmt_openContext.prototype.selectstmt = function() { + return this.getTypedRuleContext(SelectstmtContext,0); +}; + +Stmt_openContext.prototype.EXECUTE = function() { + return this.getToken(PostgreSQLParser.EXECUTE, 0); +}; + +Stmt_openContext.prototype.sql_expression = function() { + return this.getTypedRuleContext(Sql_expressionContext,0); +}; + +Stmt_openContext.prototype.opt_open_using = function() { + return this.getTypedRuleContext(Opt_open_usingContext,0); +}; + +Stmt_openContext.prototype.OPEN_PAREN = function() { + return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); +}; + +Stmt_openContext.prototype.opt_open_bound_list = function() { + return this.getTypedRuleContext(Opt_open_bound_listContext,0); +}; + +Stmt_openContext.prototype.CLOSE_PAREN = function() { + return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); +}; + +Stmt_openContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_open(this); + } +}; + +Stmt_openContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_open(this); + } +}; + +Stmt_openContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_open(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_openContext = Stmt_openContext; + +PostgreSQLParser.prototype.stmt_open = function() { + + var localctx = new Stmt_openContext(this, this._ctx, this.state); + this.enterRule(localctx, 1536, PostgreSQLParser.RULE_stmt_open); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10351; + this.match(PostgreSQLParser.OPEN); + this.state = 10369; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,698,this._ctx); + switch(la_) { + case 1: + this.state = 10352; + this.cursor_variable(); + this.state = 10353; + this.opt_scroll_option(); + this.state = 10354; + this.match(PostgreSQLParser.FOR); + this.state = 10360; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.OPEN_PAREN: + case PostgreSQLParser.SELECT: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.WITH: + case PostgreSQLParser.VALUES: + this.state = 10355; + this.selectstmt(); + break; + case PostgreSQLParser.EXECUTE: + this.state = 10356; + this.match(PostgreSQLParser.EXECUTE); + this.state = 10357; + this.sql_expression(); + this.state = 10358; + this.opt_open_using(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + break; + + case 2: + this.state = 10362; + this.colid(); + this.state = 10367; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.OPEN_PAREN) { + this.state = 10363; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 10364; + this.opt_open_bound_list(); + this.state = 10365; + this.match(PostgreSQLParser.CLOSE_PAREN); + } + + break; + + } + this.state = 10371; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_open_bound_list_itemContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_open_bound_list_item; + return this; +} + +Opt_open_bound_list_itemContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_open_bound_list_itemContext.prototype.constructor = Opt_open_bound_list_itemContext; + +Opt_open_bound_list_itemContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Opt_open_bound_list_itemContext.prototype.COLON_EQUALS = function() { + return this.getToken(PostgreSQLParser.COLON_EQUALS, 0); +}; + +Opt_open_bound_list_itemContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Opt_open_bound_list_itemContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_open_bound_list_item(this); + } +}; + +Opt_open_bound_list_itemContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_open_bound_list_item(this); + } +}; + +Opt_open_bound_list_itemContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_open_bound_list_item(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_open_bound_list_itemContext = Opt_open_bound_list_itemContext; + +PostgreSQLParser.prototype.opt_open_bound_list_item = function() { + + var localctx = new Opt_open_bound_list_itemContext(this, this._ctx, this.state); + this.enterRule(localctx, 1538, PostgreSQLParser.RULE_opt_open_bound_list_item); + try { + this.state = 10378; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,699,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 10373; + this.colid(); + this.state = 10374; + this.match(PostgreSQLParser.COLON_EQUALS); + this.state = 10375; + this.a_expr(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 10377; + this.a_expr(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_open_bound_listContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_open_bound_list; + return this; +} + +Opt_open_bound_listContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_open_bound_listContext.prototype.constructor = Opt_open_bound_listContext; + +Opt_open_bound_listContext.prototype.opt_open_bound_list_item = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Opt_open_bound_list_itemContext); + } else { + return this.getTypedRuleContext(Opt_open_bound_list_itemContext,i); + } +}; + +Opt_open_bound_listContext.prototype.COMMA = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } +}; + + +Opt_open_bound_listContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_open_bound_list(this); + } +}; + +Opt_open_bound_listContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_open_bound_list(this); + } +}; + +Opt_open_bound_listContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_open_bound_list(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_open_bound_listContext = Opt_open_bound_listContext; + +PostgreSQLParser.prototype.opt_open_bound_list = function() { + + var localctx = new Opt_open_bound_listContext(this, this._ctx, this.state); + this.enterRule(localctx, 1540, PostgreSQLParser.RULE_opt_open_bound_list); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10380; + this.opt_open_bound_list_item(); + this.state = 10385; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.COMMA) { + this.state = 10381; + this.match(PostgreSQLParser.COMMA); + this.state = 10382; + this.opt_open_bound_list_item(); + this.state = 10387; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_open_usingContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_open_using; + return this; +} + +Opt_open_usingContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_open_usingContext.prototype.constructor = Opt_open_usingContext; + +Opt_open_usingContext.prototype.USING = function() { + return this.getToken(PostgreSQLParser.USING, 0); +}; + +Opt_open_usingContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Opt_open_usingContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_open_using(this); + } +}; + +Opt_open_usingContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_open_using(this); + } +}; + +Opt_open_usingContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_open_using(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_open_usingContext = Opt_open_usingContext; + +PostgreSQLParser.prototype.opt_open_using = function() { + + var localctx = new Opt_open_usingContext(this, this._ctx, this.state); + this.enterRule(localctx, 1542, PostgreSQLParser.RULE_opt_open_using); + try { + this.state = 10391; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SEMI: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.USING: + this.enterOuterAlt(localctx, 2); + this.state = 10389; + this.match(PostgreSQLParser.USING); + this.state = 10390; + this.expr_list(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_scroll_optionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_scroll_option; + return this; +} + +Opt_scroll_optionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_scroll_optionContext.prototype.constructor = Opt_scroll_optionContext; + +Opt_scroll_optionContext.prototype.opt_scroll_option_no = function() { + return this.getTypedRuleContext(Opt_scroll_option_noContext,0); +}; + +Opt_scroll_optionContext.prototype.SCROLL = function() { + return this.getToken(PostgreSQLParser.SCROLL, 0); +}; + +Opt_scroll_optionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_scroll_option(this); + } +}; + +Opt_scroll_optionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_scroll_option(this); + } +}; + +Opt_scroll_optionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_scroll_option(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_scroll_optionContext = Opt_scroll_optionContext; + +PostgreSQLParser.prototype.opt_scroll_option = function() { + + var localctx = new Opt_scroll_optionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1544, PostgreSQLParser.RULE_opt_scroll_option); + try { + this.state = 10397; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FOR: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.NO: + case PostgreSQLParser.SCROLL: + this.enterOuterAlt(localctx, 2); + this.state = 10394; + this.opt_scroll_option_no(); + this.state = 10395; + this.match(PostgreSQLParser.SCROLL); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_scroll_option_noContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_scroll_option_no; + return this; +} + +Opt_scroll_option_noContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_scroll_option_noContext.prototype.constructor = Opt_scroll_option_noContext; + +Opt_scroll_option_noContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Opt_scroll_option_noContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_scroll_option_no(this); + } +}; + +Opt_scroll_option_noContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_scroll_option_no(this); + } +}; + +Opt_scroll_option_noContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_scroll_option_no(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_scroll_option_noContext = Opt_scroll_option_noContext; + +PostgreSQLParser.prototype.opt_scroll_option_no = function() { + + var localctx = new Opt_scroll_option_noContext(this, this._ctx, this.state); + this.enterRule(localctx, 1546, PostgreSQLParser.RULE_opt_scroll_option_no); + try { + this.state = 10401; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SCROLL: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.NO: + this.enterOuterAlt(localctx, 2); + this.state = 10400; + this.match(PostgreSQLParser.NO); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_fetchContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_fetch; + this.direction = null; // Opt_fetch_directionContext + return this; +} + +Stmt_fetchContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_fetchContext.prototype.constructor = Stmt_fetchContext; + +Stmt_fetchContext.prototype.FETCH = function() { + return this.getToken(PostgreSQLParser.FETCH, 0); +}; + +Stmt_fetchContext.prototype.opt_cursor_from = function() { + return this.getTypedRuleContext(Opt_cursor_fromContext,0); +}; + +Stmt_fetchContext.prototype.cursor_variable = function() { + return this.getTypedRuleContext(Cursor_variableContext,0); +}; + +Stmt_fetchContext.prototype.INTO = function() { + return this.getToken(PostgreSQLParser.INTO, 0); +}; + +Stmt_fetchContext.prototype.into_target = function() { + return this.getTypedRuleContext(Into_targetContext,0); +}; + +Stmt_fetchContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_fetchContext.prototype.opt_fetch_direction = function() { + return this.getTypedRuleContext(Opt_fetch_directionContext,0); +}; + +Stmt_fetchContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_fetch(this); + } +}; + +Stmt_fetchContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_fetch(this); + } +}; + +Stmt_fetchContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_fetch(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_fetchContext = Stmt_fetchContext; + +PostgreSQLParser.prototype.stmt_fetch = function() { + + var localctx = new Stmt_fetchContext(this, this._ctx, this.state); + this.enterRule(localctx, 1548, PostgreSQLParser.RULE_stmt_fetch); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10403; + this.match(PostgreSQLParser.FETCH); + this.state = 10404; + localctx.direction = this.opt_fetch_direction(); + this.state = 10405; + this.opt_cursor_from(); + this.state = 10406; + this.cursor_variable(); + this.state = 10407; + this.match(PostgreSQLParser.INTO); + this.state = 10408; + this.into_target(); + this.state = 10409; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Into_targetContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_into_target; + return this; +} + +Into_targetContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Into_targetContext.prototype.constructor = Into_targetContext; + +Into_targetContext.prototype.expr_list = function() { + return this.getTypedRuleContext(Expr_listContext,0); +}; + +Into_targetContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterInto_target(this); + } +}; + +Into_targetContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitInto_target(this); + } +}; + +Into_targetContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitInto_target(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Into_targetContext = Into_targetContext; + +PostgreSQLParser.prototype.into_target = function() { + + var localctx = new Into_targetContext(this, this._ctx, this.state); + this.enterRule(localctx, 1550, PostgreSQLParser.RULE_into_target); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10411; + this.expr_list(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_cursor_fromContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_cursor_from; + return this; +} + +Opt_cursor_fromContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_cursor_fromContext.prototype.constructor = Opt_cursor_fromContext; + +Opt_cursor_fromContext.prototype.FROM = function() { + return this.getToken(PostgreSQLParser.FROM, 0); +}; + +Opt_cursor_fromContext.prototype.IN_P = function() { + return this.getToken(PostgreSQLParser.IN_P, 0); +}; + +Opt_cursor_fromContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_cursor_from(this); + } +}; + +Opt_cursor_fromContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_cursor_from(this); + } +}; + +Opt_cursor_fromContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_cursor_from(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_cursor_fromContext = Opt_cursor_fromContext; + +PostgreSQLParser.prototype.opt_cursor_from = function() { + + var localctx = new Opt_cursor_fromContext(this, this._ctx, this.state); + this.enterRule(localctx, 1552, PostgreSQLParser.RULE_opt_cursor_from); + try { + this.state = 10416; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.PARAM: + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.FROM: + this.enterOuterAlt(localctx, 2); + this.state = 10414; + this.match(PostgreSQLParser.FROM); + break; + case PostgreSQLParser.IN_P: + this.enterOuterAlt(localctx, 3); + this.state = 10415; + this.match(PostgreSQLParser.IN_P); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_fetch_directionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_fetch_direction; + return this; +} + +Opt_fetch_directionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_fetch_directionContext.prototype.constructor = Opt_fetch_directionContext; + +Opt_fetch_directionContext.prototype.NEXT = function() { + return this.getToken(PostgreSQLParser.NEXT, 0); +}; + +Opt_fetch_directionContext.prototype.PRIOR = function() { + return this.getToken(PostgreSQLParser.PRIOR, 0); +}; + +Opt_fetch_directionContext.prototype.FIRST_P = function() { + return this.getToken(PostgreSQLParser.FIRST_P, 0); +}; + +Opt_fetch_directionContext.prototype.LAST_P = function() { + return this.getToken(PostgreSQLParser.LAST_P, 0); +}; + +Opt_fetch_directionContext.prototype.ABSOLUTE_P = function() { + return this.getToken(PostgreSQLParser.ABSOLUTE_P, 0); +}; + +Opt_fetch_directionContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Opt_fetch_directionContext.prototype.RELATIVE_P = function() { + return this.getToken(PostgreSQLParser.RELATIVE_P, 0); +}; + +Opt_fetch_directionContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Opt_fetch_directionContext.prototype.FORWARD = function() { + return this.getToken(PostgreSQLParser.FORWARD, 0); +}; + +Opt_fetch_directionContext.prototype.BACKWARD = function() { + return this.getToken(PostgreSQLParser.BACKWARD, 0); +}; + +Opt_fetch_directionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_fetch_direction(this); + } +}; + +Opt_fetch_directionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_fetch_direction(this); + } +}; + +Opt_fetch_directionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_fetch_direction(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_fetch_directionContext = Opt_fetch_directionContext; + +PostgreSQLParser.prototype.opt_fetch_direction = function() { + + var localctx = new Opt_fetch_directionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1554, PostgreSQLParser.RULE_opt_fetch_direction); + var _la = 0; // Token type + try { + this.state = 10435; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,706,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + + break; + + case 2: + this.enterOuterAlt(localctx, 2); + + break; + + case 3: + this.enterOuterAlt(localctx, 3); + this.state = 10420; + this.match(PostgreSQLParser.NEXT); + break; + + case 4: + this.enterOuterAlt(localctx, 4); + this.state = 10421; + this.match(PostgreSQLParser.PRIOR); + break; + + case 5: + this.enterOuterAlt(localctx, 5); + this.state = 10422; + this.match(PostgreSQLParser.FIRST_P); + break; + + case 6: + this.enterOuterAlt(localctx, 6); + this.state = 10423; + this.match(PostgreSQLParser.LAST_P); + break; + + case 7: + this.enterOuterAlt(localctx, 7); + this.state = 10424; + this.match(PostgreSQLParser.ABSOLUTE_P); + this.state = 10425; + this.a_expr(); + break; + + case 8: + this.enterOuterAlt(localctx, 8); + this.state = 10426; + this.match(PostgreSQLParser.RELATIVE_P); + this.state = 10427; + this.a_expr(); + break; + + case 9: + this.enterOuterAlt(localctx, 9); + this.state = 10428; + this.a_expr(); + break; + + case 10: + this.enterOuterAlt(localctx, 10); + this.state = 10429; + this.match(PostgreSQLParser.ALL); + break; + + case 11: + this.enterOuterAlt(localctx, 11); + this.state = 10430; + _la = this._input.LA(1); + if(!(_la===PostgreSQLParser.BACKWARD || _la===PostgreSQLParser.FORWARD)) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + this.state = 10433; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,705,this._ctx); + if(la_===1) { + this.state = 10431; + this.a_expr(); + + } else if(la_===2) { + this.state = 10432; + this.match(PostgreSQLParser.ALL); + + } + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_moveContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_move; + return this; +} + +Stmt_moveContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_moveContext.prototype.constructor = Stmt_moveContext; + +Stmt_moveContext.prototype.MOVE = function() { + return this.getToken(PostgreSQLParser.MOVE, 0); +}; + +Stmt_moveContext.prototype.opt_fetch_direction = function() { + return this.getTypedRuleContext(Opt_fetch_directionContext,0); +}; + +Stmt_moveContext.prototype.cursor_variable = function() { + return this.getTypedRuleContext(Cursor_variableContext,0); +}; + +Stmt_moveContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_moveContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_move(this); + } +}; + +Stmt_moveContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_move(this); + } +}; + +Stmt_moveContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_move(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_moveContext = Stmt_moveContext; + +PostgreSQLParser.prototype.stmt_move = function() { + + var localctx = new Stmt_moveContext(this, this._ctx, this.state); + this.enterRule(localctx, 1556, PostgreSQLParser.RULE_stmt_move); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10437; + this.match(PostgreSQLParser.MOVE); + this.state = 10438; + this.opt_fetch_direction(); + this.state = 10439; + this.cursor_variable(); + this.state = 10440; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_closeContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_close; + return this; +} + +Stmt_closeContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_closeContext.prototype.constructor = Stmt_closeContext; + +Stmt_closeContext.prototype.CLOSE = function() { + return this.getToken(PostgreSQLParser.CLOSE, 0); +}; + +Stmt_closeContext.prototype.cursor_variable = function() { + return this.getTypedRuleContext(Cursor_variableContext,0); +}; + +Stmt_closeContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_closeContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_close(this); + } +}; + +Stmt_closeContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_close(this); + } +}; + +Stmt_closeContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_close(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_closeContext = Stmt_closeContext; + +PostgreSQLParser.prototype.stmt_close = function() { + + var localctx = new Stmt_closeContext(this, this._ctx, this.state); + this.enterRule(localctx, 1558, PostgreSQLParser.RULE_stmt_close); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10442; + this.match(PostgreSQLParser.CLOSE); + this.state = 10443; + this.cursor_variable(); + this.state = 10444; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_nullContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_null; + return this; +} + +Stmt_nullContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_nullContext.prototype.constructor = Stmt_nullContext; + +Stmt_nullContext.prototype.NULL_P = function() { + return this.getToken(PostgreSQLParser.NULL_P, 0); +}; + +Stmt_nullContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_nullContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_null(this); + } +}; + +Stmt_nullContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_null(this); + } +}; + +Stmt_nullContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_null(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_nullContext = Stmt_nullContext; + +PostgreSQLParser.prototype.stmt_null = function() { + + var localctx = new Stmt_nullContext(this, this._ctx, this.state); + this.enterRule(localctx, 1560, PostgreSQLParser.RULE_stmt_null); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10446; + this.match(PostgreSQLParser.NULL_P); + this.state = 10447; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_commitContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_commit; + return this; +} + +Stmt_commitContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_commitContext.prototype.constructor = Stmt_commitContext; + +Stmt_commitContext.prototype.COMMIT = function() { + return this.getToken(PostgreSQLParser.COMMIT, 0); +}; + +Stmt_commitContext.prototype.plsql_opt_transaction_chain = function() { + return this.getTypedRuleContext(Plsql_opt_transaction_chainContext,0); +}; + +Stmt_commitContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_commitContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_commit(this); + } +}; + +Stmt_commitContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_commit(this); + } +}; + +Stmt_commitContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_commit(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_commitContext = Stmt_commitContext; + +PostgreSQLParser.prototype.stmt_commit = function() { + + var localctx = new Stmt_commitContext(this, this._ctx, this.state); + this.enterRule(localctx, 1562, PostgreSQLParser.RULE_stmt_commit); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10449; + this.match(PostgreSQLParser.COMMIT); + this.state = 10450; + this.plsql_opt_transaction_chain(); + this.state = 10451; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_rollbackContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_rollback; + return this; +} + +Stmt_rollbackContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_rollbackContext.prototype.constructor = Stmt_rollbackContext; + +Stmt_rollbackContext.prototype.ROLLBACK = function() { + return this.getToken(PostgreSQLParser.ROLLBACK, 0); +}; + +Stmt_rollbackContext.prototype.plsql_opt_transaction_chain = function() { + return this.getTypedRuleContext(Plsql_opt_transaction_chainContext,0); +}; + +Stmt_rollbackContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_rollbackContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_rollback(this); + } +}; + +Stmt_rollbackContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_rollback(this); + } +}; + +Stmt_rollbackContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_rollback(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_rollbackContext = Stmt_rollbackContext; + +PostgreSQLParser.prototype.stmt_rollback = function() { + + var localctx = new Stmt_rollbackContext(this, this._ctx, this.state); + this.enterRule(localctx, 1564, PostgreSQLParser.RULE_stmt_rollback); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10453; + this.match(PostgreSQLParser.ROLLBACK); + this.state = 10454; + this.plsql_opt_transaction_chain(); + this.state = 10455; + this.match(PostgreSQLParser.SEMI); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Plsql_opt_transaction_chainContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_plsql_opt_transaction_chain; + return this; +} + +Plsql_opt_transaction_chainContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Plsql_opt_transaction_chainContext.prototype.constructor = Plsql_opt_transaction_chainContext; + +Plsql_opt_transaction_chainContext.prototype.AND = function() { + return this.getToken(PostgreSQLParser.AND, 0); +}; + +Plsql_opt_transaction_chainContext.prototype.CHAIN = function() { + return this.getToken(PostgreSQLParser.CHAIN, 0); +}; + +Plsql_opt_transaction_chainContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Plsql_opt_transaction_chainContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPlsql_opt_transaction_chain(this); + } +}; + +Plsql_opt_transaction_chainContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPlsql_opt_transaction_chain(this); + } +}; + +Plsql_opt_transaction_chainContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPlsql_opt_transaction_chain(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Plsql_opt_transaction_chainContext = Plsql_opt_transaction_chainContext; + +PostgreSQLParser.prototype.plsql_opt_transaction_chain = function() { + + var localctx = new Plsql_opt_transaction_chainContext(this, this._ctx, this.state); + this.enterRule(localctx, 1566, PostgreSQLParser.RULE_plsql_opt_transaction_chain); + var _la = 0; // Token type + try { + this.state = 10463; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + this.enterOuterAlt(localctx, 1); + this.state = 10457; + this.match(PostgreSQLParser.AND); + this.state = 10459; + this._errHandler.sync(this); + _la = this._input.LA(1); + if(_la===PostgreSQLParser.NO) { + this.state = 10458; + this.match(PostgreSQLParser.NO); + } + + this.state = 10461; + this.match(PostgreSQLParser.CHAIN); + break; + case PostgreSQLParser.SEMI: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Stmt_setContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_stmt_set; + return this; +} + +Stmt_setContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Stmt_setContext.prototype.constructor = Stmt_setContext; + +Stmt_setContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +Stmt_setContext.prototype.any_name = function() { + return this.getTypedRuleContext(Any_nameContext,0); +}; + +Stmt_setContext.prototype.TO = function() { + return this.getToken(PostgreSQLParser.TO, 0); +}; + +Stmt_setContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Stmt_setContext.prototype.SEMI = function() { + return this.getToken(PostgreSQLParser.SEMI, 0); +}; + +Stmt_setContext.prototype.RESET = function() { + return this.getToken(PostgreSQLParser.RESET, 0); +}; + +Stmt_setContext.prototype.ALL = function() { + return this.getToken(PostgreSQLParser.ALL, 0); +}; + +Stmt_setContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterStmt_set(this); + } +}; + +Stmt_setContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitStmt_set(this); + } +}; + +Stmt_setContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitStmt_set(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Stmt_setContext = Stmt_setContext; + +PostgreSQLParser.prototype.stmt_set = function() { + + var localctx = new Stmt_setContext(this, this._ctx, this.state); + this.enterRule(localctx, 1568, PostgreSQLParser.RULE_stmt_set); + try { + this.state = 10477; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.SET: + this.enterOuterAlt(localctx, 1); + this.state = 10465; + this.match(PostgreSQLParser.SET); + this.state = 10466; + this.any_name(); + this.state = 10467; + this.match(PostgreSQLParser.TO); + this.state = 10468; + this.match(PostgreSQLParser.DEFAULT); + this.state = 10469; + this.match(PostgreSQLParser.SEMI); + break; + case PostgreSQLParser.RESET: + this.enterOuterAlt(localctx, 2); + this.state = 10471; + this.match(PostgreSQLParser.RESET); + this.state = 10474; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.state = 10472; + this.any_name(); + break; + case PostgreSQLParser.ALL: + this.state = 10473; + this.match(PostgreSQLParser.ALL); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + this.state = 10476; + this.match(PostgreSQLParser.SEMI); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Cursor_variableContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_cursor_variable; + return this; +} + +Cursor_variableContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Cursor_variableContext.prototype.constructor = Cursor_variableContext; + +Cursor_variableContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Cursor_variableContext.prototype.PARAM = function() { + return this.getToken(PostgreSQLParser.PARAM, 0); +}; + +Cursor_variableContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterCursor_variable(this); + } +}; + +Cursor_variableContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitCursor_variable(this); + } +}; + +Cursor_variableContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitCursor_variable(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Cursor_variableContext = Cursor_variableContext; + +PostgreSQLParser.prototype.cursor_variable = function() { + + var localctx = new Cursor_variableContext(this, this._ctx, this.state); + this.enterRule(localctx, 1570, PostgreSQLParser.RULE_cursor_variable); + try { + this.state = 10481; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 1); + this.state = 10479; + this.colid(); + break; + case PostgreSQLParser.PARAM: + this.enterOuterAlt(localctx, 2); + this.state = 10480; + this.match(PostgreSQLParser.PARAM); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Exception_sectContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_exception_sect; + return this; +} + +Exception_sectContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Exception_sectContext.prototype.constructor = Exception_sectContext; + +Exception_sectContext.prototype.EXCEPTION = function() { + return this.getToken(PostgreSQLParser.EXCEPTION, 0); +}; + +Exception_sectContext.prototype.proc_exceptions = function() { + return this.getTypedRuleContext(Proc_exceptionsContext,0); +}; + +Exception_sectContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterException_sect(this); + } +}; + +Exception_sectContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitException_sect(this); + } +}; + +Exception_sectContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitException_sect(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Exception_sectContext = Exception_sectContext; + +PostgreSQLParser.prototype.exception_sect = function() { + + var localctx = new Exception_sectContext(this, this._ctx, this.state); + this.enterRule(localctx, 1572, PostgreSQLParser.RULE_exception_sect); + try { + this.state = 10486; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.END_P: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.EXCEPTION: + this.enterOuterAlt(localctx, 2); + this.state = 10484; + this.match(PostgreSQLParser.EXCEPTION); + this.state = 10485; + this.proc_exceptions(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Proc_exceptionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_proc_exceptions; + return this; +} + +Proc_exceptionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Proc_exceptionsContext.prototype.constructor = Proc_exceptionsContext; + +Proc_exceptionsContext.prototype.proc_exception = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Proc_exceptionContext); + } else { + return this.getTypedRuleContext(Proc_exceptionContext,i); + } +}; + +Proc_exceptionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterProc_exceptions(this); + } +}; + +Proc_exceptionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitProc_exceptions(this); + } +}; + +Proc_exceptionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitProc_exceptions(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Proc_exceptionsContext = Proc_exceptionsContext; + +PostgreSQLParser.prototype.proc_exceptions = function() { + + var localctx = new Proc_exceptionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 1574, PostgreSQLParser.RULE_proc_exceptions); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10489; + this._errHandler.sync(this); + _la = this._input.LA(1); + do { + this.state = 10488; + this.proc_exception(); + this.state = 10491; + this._errHandler.sync(this); + _la = this._input.LA(1); + } while(_la===PostgreSQLParser.WHEN); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Proc_exceptionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_proc_exception; + return this; +} + +Proc_exceptionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Proc_exceptionContext.prototype.constructor = Proc_exceptionContext; + +Proc_exceptionContext.prototype.WHEN = function() { + return this.getToken(PostgreSQLParser.WHEN, 0); +}; + +Proc_exceptionContext.prototype.proc_conditions = function() { + return this.getTypedRuleContext(Proc_conditionsContext,0); +}; + +Proc_exceptionContext.prototype.THEN = function() { + return this.getToken(PostgreSQLParser.THEN, 0); +}; + +Proc_exceptionContext.prototype.proc_sect = function() { + return this.getTypedRuleContext(Proc_sectContext,0); +}; + +Proc_exceptionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterProc_exception(this); + } +}; + +Proc_exceptionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitProc_exception(this); + } +}; + +Proc_exceptionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitProc_exception(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Proc_exceptionContext = Proc_exceptionContext; + +PostgreSQLParser.prototype.proc_exception = function() { + + var localctx = new Proc_exceptionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1576, PostgreSQLParser.RULE_proc_exception); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10493; + this.match(PostgreSQLParser.WHEN); + this.state = 10494; + this.proc_conditions(); + this.state = 10495; + this.match(PostgreSQLParser.THEN); + this.state = 10496; + this.proc_sect(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Proc_conditionsContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_proc_conditions; + return this; +} + +Proc_conditionsContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Proc_conditionsContext.prototype.constructor = Proc_conditionsContext; + +Proc_conditionsContext.prototype.proc_condition = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTypedRuleContexts(Proc_conditionContext); + } else { + return this.getTypedRuleContext(Proc_conditionContext,i); + } +}; + +Proc_conditionsContext.prototype.OR = function(i) { + if(i===undefined) { + i = null; + } + if(i===null) { + return this.getTokens(PostgreSQLParser.OR); + } else { + return this.getToken(PostgreSQLParser.OR, i); + } +}; + + +Proc_conditionsContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterProc_conditions(this); + } +}; + +Proc_conditionsContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitProc_conditions(this); + } +}; + +Proc_conditionsContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitProc_conditions(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Proc_conditionsContext = Proc_conditionsContext; + +PostgreSQLParser.prototype.proc_conditions = function() { + + var localctx = new Proc_conditionsContext(this, this._ctx, this.state); + this.enterRule(localctx, 1578, PostgreSQLParser.RULE_proc_conditions); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10498; + this.proc_condition(); + this.state = 10503; + this._errHandler.sync(this); + _la = this._input.LA(1); + while(_la===PostgreSQLParser.OR) { + this.state = 10499; + this.match(PostgreSQLParser.OR); + this.state = 10500; + this.proc_condition(); + this.state = 10505; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Proc_conditionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_proc_condition; + return this; +} + +Proc_conditionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Proc_conditionContext.prototype.constructor = Proc_conditionContext; + +Proc_conditionContext.prototype.any_identifier = function() { + return this.getTypedRuleContext(Any_identifierContext,0); +}; + +Proc_conditionContext.prototype.SQLSTATE = function() { + return this.getToken(PostgreSQLParser.SQLSTATE, 0); +}; + +Proc_conditionContext.prototype.sconst = function() { + return this.getTypedRuleContext(SconstContext,0); +}; + +Proc_conditionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterProc_condition(this); + } +}; + +Proc_conditionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitProc_condition(this); + } +}; + +Proc_conditionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitProc_condition(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Proc_conditionContext = Proc_conditionContext; + +PostgreSQLParser.prototype.proc_condition = function() { + + var localctx = new Proc_conditionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1580, PostgreSQLParser.RULE_proc_condition); + try { + this.state = 10509; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,715,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 10506; + this.any_identifier(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 10507; + this.match(PostgreSQLParser.SQLSTATE); + this.state = 10508; + this.sconst(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_block_labelContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_block_label; + return this; +} + +Opt_block_labelContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_block_labelContext.prototype.constructor = Opt_block_labelContext; + +Opt_block_labelContext.prototype.label_decl = function() { + return this.getTypedRuleContext(Label_declContext,0); +}; + +Opt_block_labelContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_block_label(this); + } +}; + +Opt_block_labelContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_block_label(this); + } +}; + +Opt_block_labelContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_block_label(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_block_labelContext = Opt_block_labelContext; + +PostgreSQLParser.prototype.opt_block_label = function() { + + var localctx = new Opt_block_labelContext(this, this._ctx, this.state); + this.enterRule(localctx, 1582, PostgreSQLParser.RULE_opt_block_label); + try { + this.state = 10513; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.DECLARE: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.LESS_LESS: + this.enterOuterAlt(localctx, 2); + this.state = 10512; + this.label_decl(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_loop_labelContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_loop_label; + return this; +} + +Opt_loop_labelContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_loop_labelContext.prototype.constructor = Opt_loop_labelContext; + +Opt_loop_labelContext.prototype.label_decl = function() { + return this.getTypedRuleContext(Label_declContext,0); +}; + +Opt_loop_labelContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_loop_label(this); + } +}; + +Opt_loop_labelContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_loop_label(this); + } +}; + +Opt_loop_labelContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_loop_label(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_loop_labelContext = Opt_loop_labelContext; + +PostgreSQLParser.prototype.opt_loop_label = function() { + + var localctx = new Opt_loop_labelContext(this, this._ctx, this.state); + this.enterRule(localctx, 1584, PostgreSQLParser.RULE_opt_loop_label); + try { + this.state = 10517; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.FOR: + case PostgreSQLParser.WHILE: + case PostgreSQLParser.FOREACH: + case PostgreSQLParser.LOOP: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.LESS_LESS: + this.enterOuterAlt(localctx, 2); + this.state = 10516; + this.label_decl(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_labelContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_label; + return this; +} + +Opt_labelContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_labelContext.prototype.constructor = Opt_labelContext; + +Opt_labelContext.prototype.any_identifier = function() { + return this.getTypedRuleContext(Any_identifierContext,0); +}; + +Opt_labelContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_label(this); + } +}; + +Opt_labelContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_label(this); + } +}; + +Opt_labelContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_label(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_labelContext = Opt_labelContext; + +PostgreSQLParser.prototype.opt_label = function() { + + var localctx = new Opt_labelContext(this, this._ctx, this.state); + this.enterRule(localctx, 1586, PostgreSQLParser.RULE_opt_label); + try { + this.state = 10521; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.EOF: + case PostgreSQLParser.SEMI: + case PostgreSQLParser.WHEN: + this.enterOuterAlt(localctx, 1); + + break; + case PostgreSQLParser.AND: + case PostgreSQLParser.ARRAY: + case PostgreSQLParser.COLLATE: + case PostgreSQLParser.COLUMN: + case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.DO: + case PostgreSQLParser.FETCH: + case PostgreSQLParser.TABLE: + case PostgreSQLParser.IS: + case PostgreSQLParser.OUTER_P: + case PostgreSQLParser.OVER: + case PostgreSQLParser.ABORT_P: + case PostgreSQLParser.ABSOLUTE_P: + case PostgreSQLParser.ACCESS: + case PostgreSQLParser.ACTION: + case PostgreSQLParser.ADD_P: + case PostgreSQLParser.ADMIN: + case PostgreSQLParser.AFTER: + case PostgreSQLParser.AGGREGATE: + case PostgreSQLParser.ALSO: + case PostgreSQLParser.ALTER: + case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.ASSERTION: + case PostgreSQLParser.ASSIGNMENT: + case PostgreSQLParser.AT: + case PostgreSQLParser.ATTRIBUTE: + case PostgreSQLParser.BACKWARD: + case PostgreSQLParser.BEFORE: + case PostgreSQLParser.BEGIN_P: + case PostgreSQLParser.BY: + case PostgreSQLParser.CACHE: + case PostgreSQLParser.CALLED: + case PostgreSQLParser.CASCADE: + case PostgreSQLParser.CASCADED: + case PostgreSQLParser.CATALOG: + case PostgreSQLParser.CHAIN: + case PostgreSQLParser.CHARACTERISTICS: + case PostgreSQLParser.CHECKPOINT: + case PostgreSQLParser.CLASS: + case PostgreSQLParser.CLOSE: + case PostgreSQLParser.CLUSTER: + case PostgreSQLParser.COMMENT: + case PostgreSQLParser.COMMENTS: + case PostgreSQLParser.COMMIT: + case PostgreSQLParser.COMMITTED: + case PostgreSQLParser.CONFIGURATION: + case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.CONSTRAINTS: + case PostgreSQLParser.CONTENT_P: + case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.CONVERSION_P: + case PostgreSQLParser.COPY: + case PostgreSQLParser.COST: + case PostgreSQLParser.CSV: + case PostgreSQLParser.CURSOR: + case PostgreSQLParser.CYCLE: + case PostgreSQLParser.DATA_P: + case PostgreSQLParser.DATABASE: + case PostgreSQLParser.DAY_P: + case PostgreSQLParser.DEALLOCATE: + case PostgreSQLParser.DECLARE: + case PostgreSQLParser.DEFAULTS: + case PostgreSQLParser.DEFERRED: + case PostgreSQLParser.DEFINER: + case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.DELIMITER: + case PostgreSQLParser.DELIMITERS: + case PostgreSQLParser.DICTIONARY: + case PostgreSQLParser.DISABLE_P: + case PostgreSQLParser.DISCARD: + case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.DOMAIN_P: + case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.DROP: + case PostgreSQLParser.EACH: + case PostgreSQLParser.ENABLE_P: + case PostgreSQLParser.ENCODING: + case PostgreSQLParser.ENCRYPTED: + case PostgreSQLParser.ENUM_P: + case PostgreSQLParser.ESCAPE: + case PostgreSQLParser.EVENT: + case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.EXCLUDING: + case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.EXPLAIN: + case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.EXTERNAL: + case PostgreSQLParser.FAMILY: + case PostgreSQLParser.FIRST_P: + case PostgreSQLParser.FOLLOWING: + case PostgreSQLParser.FORCE: + case PostgreSQLParser.FORWARD: + case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.FUNCTIONS: + case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.GRANTED: + case PostgreSQLParser.HANDLER: + case PostgreSQLParser.HEADER_P: + case PostgreSQLParser.HOLD: + case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.IF_P: + case PostgreSQLParser.IMMEDIATE: + case PostgreSQLParser.IMMUTABLE: + case PostgreSQLParser.IMPLICIT_P: + case PostgreSQLParser.INCLUDING: + case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.INDEX: + case PostgreSQLParser.INDEXES: + case PostgreSQLParser.INHERIT: + case PostgreSQLParser.INHERITS: + case PostgreSQLParser.INLINE_P: + case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.INSERT: + case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.INVOKER: + case PostgreSQLParser.ISOLATION: + case PostgreSQLParser.KEY: + case PostgreSQLParser.LABEL: + case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.LARGE_P: + case PostgreSQLParser.LAST_P: + case PostgreSQLParser.LEAKPROOF: + case PostgreSQLParser.LEVEL: + case PostgreSQLParser.LISTEN: + case PostgreSQLParser.LOAD: + case PostgreSQLParser.LOCAL: + case PostgreSQLParser.LOCATION: + case PostgreSQLParser.LOCK_P: + case PostgreSQLParser.MAPPING: + case PostgreSQLParser.MATCH: + case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.MODE: + case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.MOVE: + case PostgreSQLParser.NAME_P: + case PostgreSQLParser.NAMES: + case PostgreSQLParser.NEXT: + case PostgreSQLParser.NO: + case PostgreSQLParser.NOTHING: + case PostgreSQLParser.NOTIFY: + case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.NULLS_P: + case PostgreSQLParser.OBJECT_P: + case PostgreSQLParser.OF: + case PostgreSQLParser.OFF: + case PostgreSQLParser.OIDS: + case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.OPTION: + case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.OWNED: + case PostgreSQLParser.OWNER: + case PostgreSQLParser.PARSER: + case PostgreSQLParser.PARTIAL: + case PostgreSQLParser.PARTITION: + case PostgreSQLParser.PASSING: + case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.PLANS: + case PostgreSQLParser.PRECEDING: + case PostgreSQLParser.PREPARE: + case PostgreSQLParser.PREPARED: + case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.PRIOR: + case PostgreSQLParser.PRIVILEGES: + case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.PROCEDURE: + case PostgreSQLParser.PROGRAM: + case PostgreSQLParser.QUOTE: + case PostgreSQLParser.RANGE: + case PostgreSQLParser.READ: + case PostgreSQLParser.REASSIGN: + case PostgreSQLParser.RECHECK: + case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.REF: + case PostgreSQLParser.REFRESH: + case PostgreSQLParser.REINDEX: + case PostgreSQLParser.RELATIVE_P: + case PostgreSQLParser.RELEASE: + case PostgreSQLParser.RENAME: + case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.REPLACE: + case PostgreSQLParser.REPLICA: + case PostgreSQLParser.RESET: + case PostgreSQLParser.RESTART: + case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.RETURNS: + case PostgreSQLParser.REVOKE: + case PostgreSQLParser.ROLE: + case PostgreSQLParser.ROLLBACK: + case PostgreSQLParser.ROWS: + case PostgreSQLParser.RULE: + case PostgreSQLParser.SAVEPOINT: + case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.SCROLL: + case PostgreSQLParser.SEARCH: + case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.SECURITY: + case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.SEQUENCES: + case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.SERVER: + case PostgreSQLParser.SESSION: + case PostgreSQLParser.SET: + case PostgreSQLParser.SHARE: + case PostgreSQLParser.SHOW: + case PostgreSQLParser.SIMPLE: + case PostgreSQLParser.SNAPSHOT: + case PostgreSQLParser.STABLE: + case PostgreSQLParser.STANDALONE_P: + case PostgreSQLParser.START: + case PostgreSQLParser.STATEMENT: + case PostgreSQLParser.STATISTICS: + case PostgreSQLParser.STDIN: + case PostgreSQLParser.STDOUT: + case PostgreSQLParser.STORAGE: + case PostgreSQLParser.STRICT_P: + case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.SYSID: + case PostgreSQLParser.SYSTEM_P: + case PostgreSQLParser.TABLES: + case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.TEMP: + case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.TEXT_P: + case PostgreSQLParser.TRANSACTION: + case PostgreSQLParser.TRIGGER: + case PostgreSQLParser.TRUNCATE: + case PostgreSQLParser.TRUSTED: + case PostgreSQLParser.TYPE_P: + case PostgreSQLParser.TYPES_P: + case PostgreSQLParser.UNBOUNDED: + case PostgreSQLParser.UNCOMMITTED: + case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.UNLISTEN: + case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.UNTIL: + case PostgreSQLParser.UPDATE: + case PostgreSQLParser.VACUUM: + case PostgreSQLParser.VALID: + case PostgreSQLParser.VALIDATE: + case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.VARYING: + case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.VIEW: + case PostgreSQLParser.VOLATILE: + case PostgreSQLParser.WHITESPACE_P: + case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.WORK: + case PostgreSQLParser.WRAPPER: + case PostgreSQLParser.WRITE: + case PostgreSQLParser.XML_P: + case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.YES_P: + case PostgreSQLParser.ZONE: + case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.BIGINT: + case PostgreSQLParser.BIT: + case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.CHAR_P: + case PostgreSQLParser.CHARACTER: + case PostgreSQLParser.COALESCE: + case PostgreSQLParser.DEC: + case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.EXISTS: + case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.GREATEST: + case PostgreSQLParser.INOUT: + case PostgreSQLParser.INT_P: + case PostgreSQLParser.INTEGER: + case PostgreSQLParser.INTERVAL: + case PostgreSQLParser.LEAST: + case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.NCHAR: + case PostgreSQLParser.NONE: + case PostgreSQLParser.NULLIF: + case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.POSITION: + case PostgreSQLParser.PRECISION: + case PostgreSQLParser.REAL: + case PostgreSQLParser.ROW: + case PostgreSQLParser.SETOF: + case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.TIME: + case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.TREAT: + case PostgreSQLParser.TRIM: + case PostgreSQLParser.VALUES: + case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.XMLATTRIBUTES: + case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.XMLPI: + case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.CALL: + case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.ATTACH: + case PostgreSQLParser.DETACH: + case PostgreSQLParser.EXPRESSION: + case PostgreSQLParser.GENERATED: + case PostgreSQLParser.LOGGED: + case PostgreSQLParser.STORED: + case PostgreSQLParser.INCLUDE: + case PostgreSQLParser.ROUTINE: + case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.IMPORT_P: + case PostgreSQLParser.POLICY: + case PostgreSQLParser.METHOD: + case PostgreSQLParser.REFERENCING: + case PostgreSQLParser.NEW: + case PostgreSQLParser.OLD: + case PostgreSQLParser.VALUE_P: + case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.OUT_P: + case PostgreSQLParser.ROUTINES: + case PostgreSQLParser.SCHEMAS: + case PostgreSQLParser.PROCEDURES: + case PostgreSQLParser.INPUT_P: + case PostgreSQLParser.SUPPORT: + case PostgreSQLParser.PARALLEL: + case PostgreSQLParser.SQL_P: + case PostgreSQLParser.DEPENDS: + case PostgreSQLParser.OVERRIDING: + case PostgreSQLParser.CONFLICT: + case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.LOCKED: + case PostgreSQLParser.TIES: + case PostgreSQLParser.ROLLUP: + case PostgreSQLParser.CUBE: + case PostgreSQLParser.GROUPING: + case PostgreSQLParser.SETS: + case PostgreSQLParser.ORDINALITY: + case PostgreSQLParser.XMLTABLE: + case PostgreSQLParser.COLUMNS: + case PostgreSQLParser.XMLNAMESPACES: + case PostgreSQLParser.ROWTYPE: + case PostgreSQLParser.NORMALIZED: + case PostgreSQLParser.WITHIN: + case PostgreSQLParser.FILTER: + case PostgreSQLParser.GROUPS: + case PostgreSQLParser.OTHERS: + case PostgreSQLParser.NFC: + case PostgreSQLParser.NFD: + case PostgreSQLParser.NFKC: + case PostgreSQLParser.NFKD: + case PostgreSQLParser.UESCAPE: + case PostgreSQLParser.VIEWS: + case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.DUMP: + case PostgreSQLParser.PRINT_STRICT_PARAMS: + case PostgreSQLParser.VARIABLE_CONFLICT: + case PostgreSQLParser.ERROR: + case PostgreSQLParser.USE_VARIABLE: + case PostgreSQLParser.USE_COLUMN: + case PostgreSQLParser.ALIAS: + case PostgreSQLParser.CONSTANT: + case PostgreSQLParser.PERFORM: + case PostgreSQLParser.GET: + case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.STACKED: + case PostgreSQLParser.ELSIF: + case PostgreSQLParser.REVERSE: + case PostgreSQLParser.SLICE: + case PostgreSQLParser.EXIT: + case PostgreSQLParser.RETURN: + case PostgreSQLParser.QUERY: + case PostgreSQLParser.RAISE: + case PostgreSQLParser.SQLSTATE: + case PostgreSQLParser.DEBUG: + case PostgreSQLParser.LOG: + case PostgreSQLParser.INFO: + case PostgreSQLParser.NOTICE: + case PostgreSQLParser.WARNING: + case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.ASSERT: + case PostgreSQLParser.OPEN: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + this.enterOuterAlt(localctx, 2); + this.state = 10520; + this.any_identifier(); + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_exitcondContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_exitcond; + return this; +} + +Opt_exitcondContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_exitcondContext.prototype.constructor = Opt_exitcondContext; + +Opt_exitcondContext.prototype.WHEN = function() { + return this.getToken(PostgreSQLParser.WHEN, 0); +}; + +Opt_exitcondContext.prototype.expr_until_semi = function() { + return this.getTypedRuleContext(Expr_until_semiContext,0); +}; + +Opt_exitcondContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_exitcond(this); + } +}; + +Opt_exitcondContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_exitcond(this); + } +}; + +Opt_exitcondContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_exitcond(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_exitcondContext = Opt_exitcondContext; + +PostgreSQLParser.prototype.opt_exitcond = function() { + + var localctx = new Opt_exitcondContext(this, this._ctx, this.state); + this.enterRule(localctx, 1588, PostgreSQLParser.RULE_opt_exitcond); + try { + this.state = 10526; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.WHEN: + this.enterOuterAlt(localctx, 1); + this.state = 10523; + this.match(PostgreSQLParser.WHEN); + this.state = 10524; + this.expr_until_semi(); + break; + case PostgreSQLParser.SEMI: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Any_identifierContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_any_identifier; + return this; +} + +Any_identifierContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Any_identifierContext.prototype.constructor = Any_identifierContext; + +Any_identifierContext.prototype.colid = function() { + return this.getTypedRuleContext(ColidContext,0); +}; + +Any_identifierContext.prototype.plsql_unreserved_keyword = function() { + return this.getTypedRuleContext(Plsql_unreserved_keywordContext,0); +}; + +Any_identifierContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterAny_identifier(this); + } +}; + +Any_identifierContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitAny_identifier(this); + } +}; + +Any_identifierContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitAny_identifier(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Any_identifierContext = Any_identifierContext; + +PostgreSQLParser.prototype.any_identifier = function() { + + var localctx = new Any_identifierContext(this, this._ctx, this.state); + this.enterRule(localctx, 1590, PostgreSQLParser.RULE_any_identifier); + try { + this.state = 10530; + this._errHandler.sync(this); + var la_ = this._interp.adaptivePredict(this._input,720,this._ctx); + switch(la_) { + case 1: + this.enterOuterAlt(localctx, 1); + this.state = 10528; + this.colid(); + break; + + case 2: + this.enterOuterAlt(localctx, 2); + this.state = 10529; + this.plsql_unreserved_keyword(); + break; + + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Plsql_unreserved_keywordContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_plsql_unreserved_keyword; + return this; +} + +Plsql_unreserved_keywordContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Plsql_unreserved_keywordContext.prototype.constructor = Plsql_unreserved_keywordContext; + +Plsql_unreserved_keywordContext.prototype.ABSOLUTE_P = function() { + return this.getToken(PostgreSQLParser.ABSOLUTE_P, 0); +}; + +Plsql_unreserved_keywordContext.prototype.ALIAS = function() { + return this.getToken(PostgreSQLParser.ALIAS, 0); +}; + +Plsql_unreserved_keywordContext.prototype.AND = function() { + return this.getToken(PostgreSQLParser.AND, 0); +}; + +Plsql_unreserved_keywordContext.prototype.ARRAY = function() { + return this.getToken(PostgreSQLParser.ARRAY, 0); +}; + +Plsql_unreserved_keywordContext.prototype.ASSERT = function() { + return this.getToken(PostgreSQLParser.ASSERT, 0); +}; + +Plsql_unreserved_keywordContext.prototype.BACKWARD = function() { + return this.getToken(PostgreSQLParser.BACKWARD, 0); +}; + +Plsql_unreserved_keywordContext.prototype.CALL = function() { + return this.getToken(PostgreSQLParser.CALL, 0); +}; + +Plsql_unreserved_keywordContext.prototype.CHAIN = function() { + return this.getToken(PostgreSQLParser.CHAIN, 0); +}; + +Plsql_unreserved_keywordContext.prototype.CLOSE = function() { + return this.getToken(PostgreSQLParser.CLOSE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.COLLATE = function() { + return this.getToken(PostgreSQLParser.COLLATE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.COLUMN = function() { + return this.getToken(PostgreSQLParser.COLUMN, 0); +}; + +Plsql_unreserved_keywordContext.prototype.COMMIT = function() { + return this.getToken(PostgreSQLParser.COMMIT, 0); +}; + +Plsql_unreserved_keywordContext.prototype.CONSTANT = function() { + return this.getToken(PostgreSQLParser.CONSTANT, 0); +}; + +Plsql_unreserved_keywordContext.prototype.CONSTRAINT = function() { + return this.getToken(PostgreSQLParser.CONSTRAINT, 0); +}; + +Plsql_unreserved_keywordContext.prototype.CONTINUE_P = function() { + return this.getToken(PostgreSQLParser.CONTINUE_P, 0); +}; + +Plsql_unreserved_keywordContext.prototype.CURRENT_P = function() { + return this.getToken(PostgreSQLParser.CURRENT_P, 0); +}; + +Plsql_unreserved_keywordContext.prototype.CURSOR = function() { + return this.getToken(PostgreSQLParser.CURSOR, 0); +}; + +Plsql_unreserved_keywordContext.prototype.DEBUG = function() { + return this.getToken(PostgreSQLParser.DEBUG, 0); +}; + +Plsql_unreserved_keywordContext.prototype.DEFAULT = function() { + return this.getToken(PostgreSQLParser.DEFAULT, 0); +}; + +Plsql_unreserved_keywordContext.prototype.DIAGNOSTICS = function() { + return this.getToken(PostgreSQLParser.DIAGNOSTICS, 0); +}; + +Plsql_unreserved_keywordContext.prototype.DO = function() { + return this.getToken(PostgreSQLParser.DO, 0); +}; + +Plsql_unreserved_keywordContext.prototype.DUMP = function() { + return this.getToken(PostgreSQLParser.DUMP, 0); +}; + +Plsql_unreserved_keywordContext.prototype.ELSIF = function() { + return this.getToken(PostgreSQLParser.ELSIF, 0); +}; + +Plsql_unreserved_keywordContext.prototype.ERROR = function() { + return this.getToken(PostgreSQLParser.ERROR, 0); +}; + +Plsql_unreserved_keywordContext.prototype.EXCEPTION = function() { + return this.getToken(PostgreSQLParser.EXCEPTION, 0); +}; + +Plsql_unreserved_keywordContext.prototype.EXIT = function() { + return this.getToken(PostgreSQLParser.EXIT, 0); +}; + +Plsql_unreserved_keywordContext.prototype.FETCH = function() { + return this.getToken(PostgreSQLParser.FETCH, 0); +}; + +Plsql_unreserved_keywordContext.prototype.FIRST_P = function() { + return this.getToken(PostgreSQLParser.FIRST_P, 0); +}; + +Plsql_unreserved_keywordContext.prototype.FORWARD = function() { + return this.getToken(PostgreSQLParser.FORWARD, 0); +}; + +Plsql_unreserved_keywordContext.prototype.GET = function() { + return this.getToken(PostgreSQLParser.GET, 0); +}; + +Plsql_unreserved_keywordContext.prototype.INFO = function() { + return this.getToken(PostgreSQLParser.INFO, 0); +}; + +Plsql_unreserved_keywordContext.prototype.INSERT = function() { + return this.getToken(PostgreSQLParser.INSERT, 0); +}; + +Plsql_unreserved_keywordContext.prototype.IS = function() { + return this.getToken(PostgreSQLParser.IS, 0); +}; + +Plsql_unreserved_keywordContext.prototype.LAST_P = function() { + return this.getToken(PostgreSQLParser.LAST_P, 0); +}; + +Plsql_unreserved_keywordContext.prototype.LOG = function() { + return this.getToken(PostgreSQLParser.LOG, 0); +}; + +Plsql_unreserved_keywordContext.prototype.MOVE = function() { + return this.getToken(PostgreSQLParser.MOVE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.NEXT = function() { + return this.getToken(PostgreSQLParser.NEXT, 0); +}; + +Plsql_unreserved_keywordContext.prototype.NO = function() { + return this.getToken(PostgreSQLParser.NO, 0); +}; + +Plsql_unreserved_keywordContext.prototype.NOTICE = function() { + return this.getToken(PostgreSQLParser.NOTICE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.OPEN = function() { + return this.getToken(PostgreSQLParser.OPEN, 0); +}; + +Plsql_unreserved_keywordContext.prototype.OPTION = function() { + return this.getToken(PostgreSQLParser.OPTION, 0); +}; + +Plsql_unreserved_keywordContext.prototype.PERFORM = function() { + return this.getToken(PostgreSQLParser.PERFORM, 0); +}; + +Plsql_unreserved_keywordContext.prototype.PRINT_STRICT_PARAMS = function() { + return this.getToken(PostgreSQLParser.PRINT_STRICT_PARAMS, 0); +}; + +Plsql_unreserved_keywordContext.prototype.PRIOR = function() { + return this.getToken(PostgreSQLParser.PRIOR, 0); +}; + +Plsql_unreserved_keywordContext.prototype.QUERY = function() { + return this.getToken(PostgreSQLParser.QUERY, 0); +}; + +Plsql_unreserved_keywordContext.prototype.RAISE = function() { + return this.getToken(PostgreSQLParser.RAISE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.RELATIVE_P = function() { + return this.getToken(PostgreSQLParser.RELATIVE_P, 0); +}; + +Plsql_unreserved_keywordContext.prototype.RESET = function() { + return this.getToken(PostgreSQLParser.RESET, 0); +}; + +Plsql_unreserved_keywordContext.prototype.RETURN = function() { + return this.getToken(PostgreSQLParser.RETURN, 0); +}; + +Plsql_unreserved_keywordContext.prototype.REVERSE = function() { + return this.getToken(PostgreSQLParser.REVERSE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.ROLLBACK = function() { + return this.getToken(PostgreSQLParser.ROLLBACK, 0); +}; + +Plsql_unreserved_keywordContext.prototype.ROWTYPE = function() { + return this.getToken(PostgreSQLParser.ROWTYPE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.SCHEMA = function() { + return this.getToken(PostgreSQLParser.SCHEMA, 0); +}; + +Plsql_unreserved_keywordContext.prototype.SCROLL = function() { + return this.getToken(PostgreSQLParser.SCROLL, 0); +}; + +Plsql_unreserved_keywordContext.prototype.SET = function() { + return this.getToken(PostgreSQLParser.SET, 0); +}; + +Plsql_unreserved_keywordContext.prototype.SLICE = function() { + return this.getToken(PostgreSQLParser.SLICE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.SQLSTATE = function() { + return this.getToken(PostgreSQLParser.SQLSTATE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.STACKED = function() { + return this.getToken(PostgreSQLParser.STACKED, 0); +}; + +Plsql_unreserved_keywordContext.prototype.TABLE = function() { + return this.getToken(PostgreSQLParser.TABLE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.TYPE_P = function() { + return this.getToken(PostgreSQLParser.TYPE_P, 0); +}; + +Plsql_unreserved_keywordContext.prototype.USE_COLUMN = function() { + return this.getToken(PostgreSQLParser.USE_COLUMN, 0); +}; + +Plsql_unreserved_keywordContext.prototype.USE_VARIABLE = function() { + return this.getToken(PostgreSQLParser.USE_VARIABLE, 0); +}; + +Plsql_unreserved_keywordContext.prototype.VARIABLE_CONFLICT = function() { + return this.getToken(PostgreSQLParser.VARIABLE_CONFLICT, 0); +}; + +Plsql_unreserved_keywordContext.prototype.WARNING = function() { + return this.getToken(PostgreSQLParser.WARNING, 0); +}; + +Plsql_unreserved_keywordContext.prototype.OUTER_P = function() { + return this.getToken(PostgreSQLParser.OUTER_P, 0); +}; + +Plsql_unreserved_keywordContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterPlsql_unreserved_keyword(this); + } +}; + +Plsql_unreserved_keywordContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitPlsql_unreserved_keyword(this); + } +}; + +Plsql_unreserved_keywordContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitPlsql_unreserved_keyword(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Plsql_unreserved_keywordContext = Plsql_unreserved_keywordContext; + +PostgreSQLParser.prototype.plsql_unreserved_keyword = function() { + + var localctx = new Plsql_unreserved_keywordContext(this, this._ctx, this.state); + this.enterRule(localctx, 1592, PostgreSQLParser.RULE_plsql_unreserved_keyword); + var _la = 0; // Token type + try { + this.enterOuterAlt(localctx, 1); + this.state = 10532; + _la = this._input.LA(1); + if(!(((((_la - 33)) & ~0x1f) == 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.AND - 33)) | (1 << (PostgreSQLParser.ARRAY - 33)) | (1 << (PostgreSQLParser.COLLATE - 33)) | (1 << (PostgreSQLParser.COLUMN - 33)) | (1 << (PostgreSQLParser.CONSTRAINT - 33)) | (1 << (PostgreSQLParser.DEFAULT - 33)) | (1 << (PostgreSQLParser.DO - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1f) == 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.TABLE - 92)) | (1 << (PostgreSQLParser.IS - 92)) | (1 << (PostgreSQLParser.OUTER_P - 92)))) !== 0) || ((((_la - 130)) & ~0x1f) == 0 && ((1 << (_la - 130)) & ((1 << (PostgreSQLParser.ABSOLUTE_P - 130)) | (1 << (PostgreSQLParser.BACKWARD - 130)) | (1 << (PostgreSQLParser.CHAIN - 130)) | (1 << (PostgreSQLParser.CLOSE - 130)) | (1 << (PostgreSQLParser.COMMIT - 130)))) !== 0) || _la===PostgreSQLParser.CONTINUE_P || _la===PostgreSQLParser.CURSOR || ((((_la - 207)) & ~0x1f) == 0 && ((1 << (_la - 207)) & ((1 << (PostgreSQLParser.FIRST_P - 207)) | (1 << (PostgreSQLParser.FORWARD - 207)) | (1 << (PostgreSQLParser.INSERT - 207)))) !== 0) || ((((_la - 240)) & ~0x1f) == 0 && ((1 << (_la - 240)) & ((1 << (PostgreSQLParser.LAST_P - 240)) | (1 << (PostgreSQLParser.MOVE - 240)) | (1 << (PostgreSQLParser.NEXT - 240)) | (1 << (PostgreSQLParser.NO - 240)) | (1 << (PostgreSQLParser.OPTION - 240)))) !== 0) || ((((_la - 284)) & ~0x1f) == 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.PRIOR - 284)) | (1 << (PostgreSQLParser.RELATIVE_P - 284)) | (1 << (PostgreSQLParser.RESET - 284)) | (1 << (PostgreSQLParser.ROLLBACK - 284)) | (1 << (PostgreSQLParser.SCHEMA - 284)) | (1 << (PostgreSQLParser.SCROLL - 284)))) !== 0) || _la===PostgreSQLParser.SET || _la===PostgreSQLParser.TYPE_P || _la===PostgreSQLParser.CALL || _la===PostgreSQLParser.CURRENT_P || ((((_la - 468)) & ~0x1f) == 0 && ((1 << (_la - 468)) & ((1 << (PostgreSQLParser.ROWTYPE - 468)) | (1 << (PostgreSQLParser.DUMP - 468)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 468)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 468)) | (1 << (PostgreSQLParser.ERROR - 468)) | (1 << (PostgreSQLParser.USE_VARIABLE - 468)) | (1 << (PostgreSQLParser.USE_COLUMN - 468)) | (1 << (PostgreSQLParser.ALIAS - 468)) | (1 << (PostgreSQLParser.CONSTANT - 468)) | (1 << (PostgreSQLParser.PERFORM - 468)) | (1 << (PostgreSQLParser.GET - 468)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 468)) | (1 << (PostgreSQLParser.STACKED - 468)) | (1 << (PostgreSQLParser.ELSIF - 468)) | (1 << (PostgreSQLParser.REVERSE - 468)) | (1 << (PostgreSQLParser.SLICE - 468)) | (1 << (PostgreSQLParser.EXIT - 468)) | (1 << (PostgreSQLParser.RETURN - 468)))) !== 0) || ((((_la - 500)) & ~0x1f) == 0 && ((1 << (_la - 500)) & ((1 << (PostgreSQLParser.QUERY - 500)) | (1 << (PostgreSQLParser.RAISE - 500)) | (1 << (PostgreSQLParser.SQLSTATE - 500)) | (1 << (PostgreSQLParser.DEBUG - 500)) | (1 << (PostgreSQLParser.LOG - 500)) | (1 << (PostgreSQLParser.INFO - 500)) | (1 << (PostgreSQLParser.NOTICE - 500)) | (1 << (PostgreSQLParser.WARNING - 500)) | (1 << (PostgreSQLParser.EXCEPTION - 500)) | (1 << (PostgreSQLParser.ASSERT - 500)) | (1 << (PostgreSQLParser.OPEN - 500)))) !== 0))) { + this._errHandler.recoverInline(this); + } + else { + this._errHandler.reportMatch(this); + this.consume(); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Sql_expressionContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_sql_expression; + return this; +} + +Sql_expressionContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Sql_expressionContext.prototype.constructor = Sql_expressionContext; + +Sql_expressionContext.prototype.opt_target_list = function() { + return this.getTypedRuleContext(Opt_target_listContext,0); +}; + +Sql_expressionContext.prototype.into_clause = function() { + return this.getTypedRuleContext(Into_clauseContext,0); +}; + +Sql_expressionContext.prototype.from_clause = function() { + return this.getTypedRuleContext(From_clauseContext,0); +}; + +Sql_expressionContext.prototype.where_clause = function() { + return this.getTypedRuleContext(Where_clauseContext,0); +}; + +Sql_expressionContext.prototype.group_clause = function() { + return this.getTypedRuleContext(Group_clauseContext,0); +}; + +Sql_expressionContext.prototype.having_clause = function() { + return this.getTypedRuleContext(Having_clauseContext,0); +}; + +Sql_expressionContext.prototype.window_clause = function() { + return this.getTypedRuleContext(Window_clauseContext,0); +}; + +Sql_expressionContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterSql_expression(this); + } +}; + +Sql_expressionContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitSql_expression(this); + } +}; + +Sql_expressionContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitSql_expression(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Sql_expressionContext = Sql_expressionContext; + +PostgreSQLParser.prototype.sql_expression = function() { + + var localctx = new Sql_expressionContext(this, this._ctx, this.state); + this.enterRule(localctx, 1594, PostgreSQLParser.RULE_sql_expression); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10534; + this.opt_target_list(); + this.state = 10535; + this.into_clause(); + this.state = 10536; + this.from_clause(); + this.state = 10537; + this.where_clause(); + this.state = 10538; + this.group_clause(); + this.state = 10539; + this.having_clause(); + this.state = 10540; + this.window_clause(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Expr_until_thenContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_expr_until_then; + return this; +} + +Expr_until_thenContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Expr_until_thenContext.prototype.constructor = Expr_until_thenContext; + +Expr_until_thenContext.prototype.sql_expression = function() { + return this.getTypedRuleContext(Sql_expressionContext,0); +}; + +Expr_until_thenContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExpr_until_then(this); + } +}; + +Expr_until_thenContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExpr_until_then(this); + } +}; + +Expr_until_thenContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExpr_until_then(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Expr_until_thenContext = Expr_until_thenContext; + +PostgreSQLParser.prototype.expr_until_then = function() { + + var localctx = new Expr_until_thenContext(this, this._ctx, this.state); + this.enterRule(localctx, 1596, PostgreSQLParser.RULE_expr_until_then); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10542; + this.sql_expression(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Expr_until_semiContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_expr_until_semi; + return this; +} + +Expr_until_semiContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Expr_until_semiContext.prototype.constructor = Expr_until_semiContext; + +Expr_until_semiContext.prototype.sql_expression = function() { + return this.getTypedRuleContext(Sql_expressionContext,0); +}; + +Expr_until_semiContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExpr_until_semi(this); + } +}; + +Expr_until_semiContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExpr_until_semi(this); + } +}; + +Expr_until_semiContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExpr_until_semi(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Expr_until_semiContext = Expr_until_semiContext; + +PostgreSQLParser.prototype.expr_until_semi = function() { + + var localctx = new Expr_until_semiContext(this, this._ctx, this.state); + this.enterRule(localctx, 1598, PostgreSQLParser.RULE_expr_until_semi); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10544; + this.sql_expression(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Expr_until_rightbracketContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_expr_until_rightbracket; + return this; +} + +Expr_until_rightbracketContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Expr_until_rightbracketContext.prototype.constructor = Expr_until_rightbracketContext; + +Expr_until_rightbracketContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Expr_until_rightbracketContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExpr_until_rightbracket(this); + } +}; + +Expr_until_rightbracketContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExpr_until_rightbracket(this); + } +}; + +Expr_until_rightbracketContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExpr_until_rightbracket(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Expr_until_rightbracketContext = Expr_until_rightbracketContext; + +PostgreSQLParser.prototype.expr_until_rightbracket = function() { + + var localctx = new Expr_until_rightbracketContext(this, this._ctx, this.state); + this.enterRule(localctx, 1600, PostgreSQLParser.RULE_expr_until_rightbracket); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10546; + this.a_expr(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Expr_until_loopContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_expr_until_loop; + return this; +} + +Expr_until_loopContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Expr_until_loopContext.prototype.constructor = Expr_until_loopContext; + +Expr_until_loopContext.prototype.a_expr = function() { + return this.getTypedRuleContext(A_exprContext,0); +}; + +Expr_until_loopContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterExpr_until_loop(this); + } +}; + +Expr_until_loopContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitExpr_until_loop(this); + } +}; + +Expr_until_loopContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitExpr_until_loop(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Expr_until_loopContext = Expr_until_loopContext; + +PostgreSQLParser.prototype.expr_until_loop = function() { + + var localctx = new Expr_until_loopContext(this, this._ctx, this.state); + this.enterRule(localctx, 1602, PostgreSQLParser.RULE_expr_until_loop); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10548; + this.a_expr(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Make_execsql_stmtContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_make_execsql_stmt; + return this; +} + +Make_execsql_stmtContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Make_execsql_stmtContext.prototype.constructor = Make_execsql_stmtContext; + +Make_execsql_stmtContext.prototype.stmt = function() { + return this.getTypedRuleContext(StmtContext,0); +}; + +Make_execsql_stmtContext.prototype.opt_returning_clause_into = function() { + return this.getTypedRuleContext(Opt_returning_clause_intoContext,0); +}; + +Make_execsql_stmtContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterMake_execsql_stmt(this); + } +}; + +Make_execsql_stmtContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitMake_execsql_stmt(this); + } +}; + +Make_execsql_stmtContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitMake_execsql_stmt(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Make_execsql_stmtContext = Make_execsql_stmtContext; + +PostgreSQLParser.prototype.make_execsql_stmt = function() { + + var localctx = new Make_execsql_stmtContext(this, this._ctx, this.state); + this.enterRule(localctx, 1604, PostgreSQLParser.RULE_make_execsql_stmt); + try { + this.enterOuterAlt(localctx, 1); + this.state = 10550; + this.stmt(); + this.state = 10551; + this.opt_returning_clause_into(); + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +function Opt_returning_clause_intoContext(parser, parent, invokingState) { + if(parent===undefined) { + parent = null; + } + if(invokingState===undefined || invokingState===null) { + invokingState = -1; + } + antlr4.ParserRuleContext.call(this, parent, invokingState); + this.parser = parser; + this.ruleIndex = PostgreSQLParser.RULE_opt_returning_clause_into; + return this; +} + +Opt_returning_clause_intoContext.prototype = Object.create(antlr4.ParserRuleContext.prototype); +Opt_returning_clause_intoContext.prototype.constructor = Opt_returning_clause_intoContext; + +Opt_returning_clause_intoContext.prototype.INTO = function() { + return this.getToken(PostgreSQLParser.INTO, 0); +}; + +Opt_returning_clause_intoContext.prototype.opt_strict = function() { + return this.getTypedRuleContext(Opt_strictContext,0); +}; + +Opt_returning_clause_intoContext.prototype.into_target = function() { + return this.getTypedRuleContext(Into_targetContext,0); +}; + +Opt_returning_clause_intoContext.prototype.enterRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.enterOpt_returning_clause_into(this); + } +}; + +Opt_returning_clause_intoContext.prototype.exitRule = function(listener) { + if(listener instanceof PostgreSQLParserListener ) { + listener.exitOpt_returning_clause_into(this); + } +}; + +Opt_returning_clause_intoContext.prototype.accept = function(visitor) { + if ( visitor instanceof PostgreSQLParserVisitor ) { + return visitor.visitOpt_returning_clause_into(this); + } else { + return visitor.visitChildren(this); + } +}; + + + + +PostgreSQLParser.Opt_returning_clause_intoContext = Opt_returning_clause_intoContext; + +PostgreSQLParser.prototype.opt_returning_clause_into = function() { + + var localctx = new Opt_returning_clause_intoContext(this, this._ctx, this.state); + this.enterRule(localctx, 1606, PostgreSQLParser.RULE_opt_returning_clause_into); + try { + this.state = 10558; + this._errHandler.sync(this); + switch(this._input.LA(1)) { + case PostgreSQLParser.INTO: + this.enterOuterAlt(localctx, 1); + this.state = 10553; + this.match(PostgreSQLParser.INTO); + this.state = 10554; + this.opt_strict(); + this.state = 10555; + this.into_target(); + break; + case PostgreSQLParser.SEMI: + this.enterOuterAlt(localctx, 2); + + break; + default: + throw new antlr4.error.NoViableAltException(this); + } + } catch (re) { + if(re instanceof antlr4.error.RecognitionException) { + localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } finally { + this.exitRule(); + } + return localctx; +}; + + +PostgreSQLParser.prototype.sempred = function(localctx, ruleIndex, predIndex) { + switch(ruleIndex) { + case 596: + return this.b_expr_sempred(localctx, predIndex); + default: + throw "No predicate with index:" + ruleIndex; + } +}; + +PostgreSQLParser.prototype.b_expr_sempred = function(localctx, predIndex) { + switch(predIndex) { + case 0: + return this.precpred(this._ctx, 8); + case 1: + return this.precpred(this._ctx, 7); + case 2: + return this.precpred(this._ctx, 6); + case 3: + return this.precpred(this._ctx, 5); + case 4: + return this.precpred(this._ctx, 4); + case 5: + return this.precpred(this._ctx, 10); + case 6: + return this.precpred(this._ctx, 2); + case 7: + return this.precpred(this._ctx, 1); + default: + throw "No predicate with index:" + predIndex; + } +}; + + +exports.PostgreSQLParser = PostgreSQLParser; diff --git a/src/lib/pgsql/PostgreSQLParser.tokens b/src/lib/pgsql/PostgreSQLParser.tokens new file mode 100644 index 0000000..af0800f --- /dev/null +++ b/src/lib/pgsql/PostgreSQLParser.tokens @@ -0,0 +1,1066 @@ +Dollar=1 +OPEN_PAREN=2 +CLOSE_PAREN=3 +OPEN_BRACKET=4 +CLOSE_BRACKET=5 +COMMA=6 +SEMI=7 +COLON=8 +STAR=9 +EQUAL=10 +DOT=11 +PLUS=12 +MINUS=13 +SLASH=14 +CARET=15 +LT=16 +GT=17 +LESS_LESS=18 +GREATER_GREATER=19 +COLON_EQUALS=20 +LESS_EQUALS=21 +EQUALS_GREATER=22 +GREATER_EQUALS=23 +DOT_DOT=24 +NOT_EQUALS=25 +TYPECAST=26 +PERCENT=27 +PARAM=28 +Operator=29 +ALL=30 +ANALYSE=31 +ANALYZE=32 +AND=33 +ANY=34 +ARRAY=35 +AS=36 +ASC=37 +ASYMMETRIC=38 +BOTH=39 +CASE=40 +CAST=41 +CHECK=42 +COLLATE=43 +COLUMN=44 +CONSTRAINT=45 +CREATE=46 +CURRENT_CATALOG=47 +CURRENT_DATE=48 +CURRENT_ROLE=49 +CURRENT_TIME=50 +CURRENT_TIMESTAMP=51 +CURRENT_USER=52 +DEFAULT=53 +DEFERRABLE=54 +DESC=55 +DISTINCT=56 +DO=57 +ELSE=58 +EXCEPT=59 +FALSE_P=60 +FETCH=61 +FOR=62 +FOREIGN=63 +FROM=64 +GRANT=65 +GROUP_P=66 +HAVING=67 +IN_P=68 +INITIALLY=69 +INTERSECT=70 +INTO=71 +LATERAL_P=72 +LEADING=73 +LIMIT=74 +LOCALTIME=75 +LOCALTIMESTAMP=76 +NOT=77 +NULL_P=78 +OFFSET=79 +ON=80 +ONLY=81 +OR=82 +ORDER=83 +PLACING=84 +PRIMARY=85 +REFERENCES=86 +RETURNING=87 +SELECT=88 +SESSION_USER=89 +SOME=90 +SYMMETRIC=91 +TABLE=92 +THEN=93 +TO=94 +TRAILING=95 +TRUE_P=96 +UNION=97 +UNIQUE=98 +USER=99 +USING=100 +VARIADIC=101 +WHEN=102 +WHERE=103 +WINDOW=104 +WITH=105 +AUTHORIZATION=106 +BINARY=107 +COLLATION=108 +CONCURRENTLY=109 +CROSS=110 +CURRENT_SCHEMA=111 +FREEZE=112 +FULL=113 +ILIKE=114 +INNER_P=115 +IS=116 +ISNULL=117 +JOIN=118 +LEFT=119 +LIKE=120 +NATURAL=121 +NOTNULL=122 +OUTER_P=123 +OVER=124 +OVERLAPS=125 +RIGHT=126 +SIMILAR=127 +VERBOSE=128 +ABORT_P=129 +ABSOLUTE_P=130 +ACCESS=131 +ACTION=132 +ADD_P=133 +ADMIN=134 +AFTER=135 +AGGREGATE=136 +ALSO=137 +ALTER=138 +ALWAYS=139 +ASSERTION=140 +ASSIGNMENT=141 +AT=142 +ATTRIBUTE=143 +BACKWARD=144 +BEFORE=145 +BEGIN_P=146 +BY=147 +CACHE=148 +CALLED=149 +CASCADE=150 +CASCADED=151 +CATALOG=152 +CHAIN=153 +CHARACTERISTICS=154 +CHECKPOINT=155 +CLASS=156 +CLOSE=157 +CLUSTER=158 +COMMENT=159 +COMMENTS=160 +COMMIT=161 +COMMITTED=162 +CONFIGURATION=163 +CONNECTION=164 +CONSTRAINTS=165 +CONTENT_P=166 +CONTINUE_P=167 +CONVERSION_P=168 +COPY=169 +COST=170 +CSV=171 +CURSOR=172 +CYCLE=173 +DATA_P=174 +DATABASE=175 +DAY_P=176 +DEALLOCATE=177 +DECLARE=178 +DEFAULTS=179 +DEFERRED=180 +DEFINER=181 +DELETE_P=182 +DELIMITER=183 +DELIMITERS=184 +DICTIONARY=185 +DISABLE_P=186 +DISCARD=187 +DOCUMENT_P=188 +DOMAIN_P=189 +DOUBLE_P=190 +DROP=191 +EACH=192 +ENABLE_P=193 +ENCODING=194 +ENCRYPTED=195 +ENUM_P=196 +ESCAPE=197 +EVENT=198 +EXCLUDE=199 +EXCLUDING=200 +EXCLUSIVE=201 +EXECUTE=202 +EXPLAIN=203 +EXTENSION=204 +EXTERNAL=205 +FAMILY=206 +FIRST_P=207 +FOLLOWING=208 +FORCE=209 +FORWARD=210 +FUNCTION=211 +FUNCTIONS=212 +GLOBAL=213 +GRANTED=214 +HANDLER=215 +HEADER_P=216 +HOLD=217 +HOUR_P=218 +IDENTITY_P=219 +IF_P=220 +IMMEDIATE=221 +IMMUTABLE=222 +IMPLICIT_P=223 +INCLUDING=224 +INCREMENT=225 +INDEX=226 +INDEXES=227 +INHERIT=228 +INHERITS=229 +INLINE_P=230 +INSENSITIVE=231 +INSERT=232 +INSTEAD=233 +INVOKER=234 +ISOLATION=235 +KEY=236 +LABEL=237 +LANGUAGE=238 +LARGE_P=239 +LAST_P=240 +LEAKPROOF=241 +LEVEL=242 +LISTEN=243 +LOAD=244 +LOCAL=245 +LOCATION=246 +LOCK_P=247 +MAPPING=248 +MATCH=249 +MATERIALIZED=250 +MAXVALUE=251 +MINUTE_P=252 +MINVALUE=253 +MODE=254 +MONTH_P=255 +MOVE=256 +NAME_P=257 +NAMES=258 +NEXT=259 +NO=260 +NOTHING=261 +NOTIFY=262 +NOWAIT=263 +NULLS_P=264 +OBJECT_P=265 +OF=266 +OFF=267 +OIDS=268 +OPERATOR=269 +OPTION=270 +OPTIONS=271 +OWNED=272 +OWNER=273 +PARSER=274 +PARTIAL=275 +PARTITION=276 +PASSING=277 +PASSWORD=278 +PLANS=279 +PRECEDING=280 +PREPARE=281 +PREPARED=282 +PRESERVE=283 +PRIOR=284 +PRIVILEGES=285 +PROCEDURAL=286 +PROCEDURE=287 +PROGRAM=288 +QUOTE=289 +RANGE=290 +READ=291 +REASSIGN=292 +RECHECK=293 +RECURSIVE=294 +REF=295 +REFRESH=296 +REINDEX=297 +RELATIVE_P=298 +RELEASE=299 +RENAME=300 +REPEATABLE=301 +REPLACE=302 +REPLICA=303 +RESET=304 +RESTART=305 +RESTRICT=306 +RETURNS=307 +REVOKE=308 +ROLE=309 +ROLLBACK=310 +ROWS=311 +RULE=312 +SAVEPOINT=313 +SCHEMA=314 +SCROLL=315 +SEARCH=316 +SECOND_P=317 +SECURITY=318 +SEQUENCE=319 +SEQUENCES=320 +SERIALIZABLE=321 +SERVER=322 +SESSION=323 +SET=324 +SHARE=325 +SHOW=326 +SIMPLE=327 +SNAPSHOT=328 +STABLE=329 +STANDALONE_P=330 +START=331 +STATEMENT=332 +STATISTICS=333 +STDIN=334 +STDOUT=335 +STORAGE=336 +STRICT_P=337 +STRIP_P=338 +SYSID=339 +SYSTEM_P=340 +TABLES=341 +TABLESPACE=342 +TEMP=343 +TEMPLATE=344 +TEMPORARY=345 +TEXT_P=346 +TRANSACTION=347 +TRIGGER=348 +TRUNCATE=349 +TRUSTED=350 +TYPE_P=351 +TYPES_P=352 +UNBOUNDED=353 +UNCOMMITTED=354 +UNENCRYPTED=355 +UNKNOWN=356 +UNLISTEN=357 +UNLOGGED=358 +UNTIL=359 +UPDATE=360 +VACUUM=361 +VALID=362 +VALIDATE=363 +VALIDATOR=364 +VARYING=365 +VERSION_P=366 +VIEW=367 +VOLATILE=368 +WHITESPACE_P=369 +WITHOUT=370 +WORK=371 +WRAPPER=372 +WRITE=373 +XML_P=374 +YEAR_P=375 +YES_P=376 +ZONE=377 +BETWEEN=378 +BIGINT=379 +BIT=380 +BOOLEAN_P=381 +CHAR_P=382 +CHARACTER=383 +COALESCE=384 +DEC=385 +DECIMAL_P=386 +EXISTS=387 +EXTRACT=388 +FLOAT_P=389 +GREATEST=390 +INOUT=391 +INT_P=392 +INTEGER=393 +INTERVAL=394 +LEAST=395 +NATIONAL=396 +NCHAR=397 +NONE=398 +NULLIF=399 +NUMERIC=400 +OVERLAY=401 +POSITION=402 +PRECISION=403 +REAL=404 +ROW=405 +SETOF=406 +SMALLINT=407 +SUBSTRING=408 +TIME=409 +TIMESTAMP=410 +TREAT=411 +TRIM=412 +VALUES=413 +VARCHAR=414 +XMLATTRIBUTES=415 +XMLCONCAT=416 +XMLELEMENT=417 +XMLEXISTS=418 +XMLFOREST=419 +XMLPARSE=420 +XMLPI=421 +XMLROOT=422 +XMLSERIALIZE=423 +CALL=424 +CURRENT_P=425 +ATTACH=426 +DETACH=427 +EXPRESSION=428 +GENERATED=429 +LOGGED=430 +STORED=431 +INCLUDE=432 +ROUTINE=433 +TRANSFORM=434 +IMPORT_P=435 +POLICY=436 +METHOD=437 +REFERENCING=438 +NEW=439 +OLD=440 +VALUE_P=441 +SUBSCRIPTION=442 +PUBLICATION=443 +OUT_P=444 +END_P=445 +ROUTINES=446 +SCHEMAS=447 +PROCEDURES=448 +INPUT_P=449 +SUPPORT=450 +PARALLEL=451 +SQL_P=452 +DEPENDS=453 +OVERRIDING=454 +CONFLICT=455 +SKIP_P=456 +LOCKED=457 +TIES=458 +ROLLUP=459 +CUBE=460 +GROUPING=461 +SETS=462 +TABLESAMPLE=463 +ORDINALITY=464 +XMLTABLE=465 +COLUMNS=466 +XMLNAMESPACES=467 +ROWTYPE=468 +NORMALIZED=469 +WITHIN=470 +FILTER=471 +GROUPS=472 +OTHERS=473 +NFC=474 +NFD=475 +NFKC=476 +NFKD=477 +UESCAPE=478 +VIEWS=479 +NORMALIZE=480 +DUMP=481 +PRINT_STRICT_PARAMS=482 +VARIABLE_CONFLICT=483 +ERROR=484 +USE_VARIABLE=485 +USE_COLUMN=486 +ALIAS=487 +CONSTANT=488 +PERFORM=489 +GET=490 +DIAGNOSTICS=491 +STACKED=492 +ELSIF=493 +WHILE=494 +REVERSE=495 +FOREACH=496 +SLICE=497 +EXIT=498 +RETURN=499 +QUERY=500 +RAISE=501 +SQLSTATE=502 +DEBUG=503 +LOG=504 +INFO=505 +NOTICE=506 +WARNING=507 +EXCEPTION=508 +ASSERT=509 +LOOP=510 +OPEN=511 +Identifier=512 +QuotedIdentifier=513 +UnterminatedQuotedIdentifier=514 +InvalidQuotedIdentifier=515 +InvalidUnterminatedQuotedIdentifier=516 +UnicodeQuotedIdentifier=517 +UnterminatedUnicodeQuotedIdentifier=518 +InvalidUnicodeQuotedIdentifier=519 +InvalidUnterminatedUnicodeQuotedIdentifier=520 +StringConstant=521 +UnterminatedStringConstant=522 +UnicodeEscapeStringConstant=523 +UnterminatedUnicodeEscapeStringConstant=524 +BeginDollarStringConstant=525 +BinaryStringConstant=526 +UnterminatedBinaryStringConstant=527 +InvalidBinaryStringConstant=528 +InvalidUnterminatedBinaryStringConstant=529 +HexadecimalStringConstant=530 +UnterminatedHexadecimalStringConstant=531 +InvalidHexadecimalStringConstant=532 +InvalidUnterminatedHexadecimalStringConstant=533 +Integral=534 +NumericFail=535 +Numeric=536 +PLSQLVARIABLENAME=537 +PLSQLIDENTIFIER=538 +Whitespace=539 +Newline=540 +LineComment=541 +BlockComment=542 +UnterminatedBlockComment=543 +MetaCommand=544 +EndMetaCommand=545 +ErrorCharacter=546 +EscapeStringConstant=547 +UnterminatedEscapeStringConstant=548 +InvalidEscapeStringConstant=549 +InvalidUnterminatedEscapeStringConstant=550 +AfterEscapeStringConstantMode_NotContinued=551 +AfterEscapeStringConstantWithNewlineMode_NotContinued=552 +DollarText=553 +EndDollarStringConstant=554 +AfterEscapeStringConstantWithNewlineMode_Continued=555 +'$'=1 +'('=2 +')'=3 +'['=4 +']'=5 +','=6 +';'=7 +':'=8 +'*'=9 +'='=10 +'.'=11 +'+'=12 +'-'=13 +'/'=14 +'^'=15 +'<'=16 +'>'=17 +'<<'=18 +'>>'=19 +':='=20 +'<='=21 +'=>'=22 +'>='=23 +'..'=24 +'<>'=25 +'::'=26 +'%'=27 +'ALL'=30 +'ANALYSE'=31 +'ANALYZE'=32 +'AND'=33 +'ANY'=34 +'ARRAY'=35 +'AS'=36 +'ASC'=37 +'ASYMMETRIC'=38 +'BOTH'=39 +'CASE'=40 +'CAST'=41 +'CHECK'=42 +'COLLATE'=43 +'COLUMN'=44 +'CONSTRAINT'=45 +'CREATE'=46 +'CURRENT_CATALOG'=47 +'CURRENT_DATE'=48 +'CURRENT_ROLE'=49 +'CURRENT_TIME'=50 +'CURRENT_TIMESTAMP'=51 +'CURRENT_USER'=52 +'DEFAULT'=53 +'DEFERRABLE'=54 +'DESC'=55 +'DISTINCT'=56 +'DO'=57 +'ELSE'=58 +'EXCEPT'=59 +'FALSE'=60 +'FETCH'=61 +'FOR'=62 +'FOREIGN'=63 +'FROM'=64 +'GRANT'=65 +'GROUP'=66 +'HAVING'=67 +'IN'=68 +'INITIALLY'=69 +'INTERSECT'=70 +'INTO'=71 +'LATERAL'=72 +'LEADING'=73 +'LIMIT'=74 +'LOCALTIME'=75 +'LOCALTIMESTAMP'=76 +'NOT'=77 +'NULL'=78 +'OFFSET'=79 +'ON'=80 +'ONLY'=81 +'OR'=82 +'ORDER'=83 +'PLACING'=84 +'PRIMARY'=85 +'REFERENCES'=86 +'RETURNING'=87 +'SELECT'=88 +'SESSION_USER'=89 +'SOME'=90 +'SYMMETRIC'=91 +'TABLE'=92 +'THEN'=93 +'TO'=94 +'TRAILING'=95 +'TRUE'=96 +'UNION'=97 +'UNIQUE'=98 +'USER'=99 +'USING'=100 +'VARIADIC'=101 +'WHEN'=102 +'WHERE'=103 +'WINDOW'=104 +'WITH'=105 +'AUTHORIZATION'=106 +'BINARY'=107 +'COLLATION'=108 +'CONCURRENTLY'=109 +'CROSS'=110 +'CURRENT_SCHEMA'=111 +'FREEZE'=112 +'FULL'=113 +'ILIKE'=114 +'INNER'=115 +'IS'=116 +'ISNULL'=117 +'JOIN'=118 +'LEFT'=119 +'LIKE'=120 +'NATURAL'=121 +'NOTNULL'=122 +'OUTER'=123 +'OVER'=124 +'OVERLAPS'=125 +'RIGHT'=126 +'SIMILAR'=127 +'VERBOSE'=128 +'ABORT'=129 +'ABSOLUTE'=130 +'ACCESS'=131 +'ACTION'=132 +'ADD'=133 +'ADMIN'=134 +'AFTER'=135 +'AGGREGATE'=136 +'ALSO'=137 +'ALTER'=138 +'ALWAYS'=139 +'ASSERTION'=140 +'ASSIGNMENT'=141 +'AT'=142 +'ATTRIBUTE'=143 +'BACKWARD'=144 +'BEFORE'=145 +'BEGIN'=146 +'BY'=147 +'CACHE'=148 +'CALLED'=149 +'CASCADE'=150 +'CASCADED'=151 +'CATALOG'=152 +'CHAIN'=153 +'CHARACTERISTICS'=154 +'CHECKPOINT'=155 +'CLASS'=156 +'CLOSE'=157 +'CLUSTER'=158 +'COMMENT'=159 +'COMMENTS'=160 +'COMMIT'=161 +'COMMITTED'=162 +'CONFIGURATION'=163 +'CONNECTION'=164 +'CONSTRAINTS'=165 +'CONTENT'=166 +'CONTINUE'=167 +'CONVERSION'=168 +'COPY'=169 +'COST'=170 +'CSV'=171 +'CURSOR'=172 +'CYCLE'=173 +'DATA'=174 +'DATABASE'=175 +'DAY'=176 +'DEALLOCATE'=177 +'DECLARE'=178 +'DEFAULTS'=179 +'DEFERRED'=180 +'DEFINER'=181 +'DELETE'=182 +'DELIMITER'=183 +'DELIMITERS'=184 +'DICTIONARY'=185 +'DISABLE'=186 +'DISCARD'=187 +'DOCUMENT'=188 +'DOMAIN'=189 +'DOUBLE'=190 +'DROP'=191 +'EACH'=192 +'ENABLE'=193 +'ENCODING'=194 +'ENCRYPTED'=195 +'ENUM'=196 +'ESCAPE'=197 +'EVENT'=198 +'EXCLUDE'=199 +'EXCLUDING'=200 +'EXCLUSIVE'=201 +'EXECUTE'=202 +'EXPLAIN'=203 +'EXTENSION'=204 +'EXTERNAL'=205 +'FAMILY'=206 +'FIRST'=207 +'FOLLOWING'=208 +'FORCE'=209 +'FORWARD'=210 +'FUNCTION'=211 +'FUNCTIONS'=212 +'GLOBAL'=213 +'GRANTED'=214 +'HANDLER'=215 +'HEADER'=216 +'HOLD'=217 +'HOUR'=218 +'IDENTITY'=219 +'IF'=220 +'IMMEDIATE'=221 +'IMMUTABLE'=222 +'IMPLICIT'=223 +'INCLUDING'=224 +'INCREMENT'=225 +'INDEX'=226 +'INDEXES'=227 +'INHERIT'=228 +'INHERITS'=229 +'INLINE'=230 +'INSENSITIVE'=231 +'INSERT'=232 +'INSTEAD'=233 +'INVOKER'=234 +'ISOLATION'=235 +'KEY'=236 +'LABEL'=237 +'LANGUAGE'=238 +'LARGE'=239 +'LAST'=240 +'LEAKPROOF'=241 +'LEVEL'=242 +'LISTEN'=243 +'LOAD'=244 +'LOCAL'=245 +'LOCATION'=246 +'LOCK'=247 +'MAPPING'=248 +'MATCH'=249 +'MATERIALIZED'=250 +'MAXVALUE'=251 +'MINUTE'=252 +'MINVALUE'=253 +'MODE'=254 +'MONTH'=255 +'MOVE'=256 +'NAME'=257 +'NAMES'=258 +'NEXT'=259 +'NO'=260 +'NOTHING'=261 +'NOTIFY'=262 +'NOWAIT'=263 +'NULLS'=264 +'OBJECT'=265 +'OF'=266 +'OFF'=267 +'OIDS'=268 +'OPERATOR'=269 +'OPTION'=270 +'OPTIONS'=271 +'OWNED'=272 +'OWNER'=273 +'PARSER'=274 +'PARTIAL'=275 +'PARTITION'=276 +'PASSING'=277 +'PASSWORD'=278 +'PLANS'=279 +'PRECEDING'=280 +'PREPARE'=281 +'PREPARED'=282 +'PRESERVE'=283 +'PRIOR'=284 +'PRIVILEGES'=285 +'PROCEDURAL'=286 +'PROCEDURE'=287 +'PROGRAM'=288 +'QUOTE'=289 +'RANGE'=290 +'READ'=291 +'REASSIGN'=292 +'RECHECK'=293 +'RECURSIVE'=294 +'REF'=295 +'REFRESH'=296 +'REINDEX'=297 +'RELATIVE'=298 +'RELEASE'=299 +'RENAME'=300 +'REPEATABLE'=301 +'REPLACE'=302 +'REPLICA'=303 +'RESET'=304 +'RESTART'=305 +'RESTRICT'=306 +'RETURNS'=307 +'REVOKE'=308 +'ROLE'=309 +'ROLLBACK'=310 +'ROWS'=311 +'RULE'=312 +'SAVEPOINT'=313 +'SCHEMA'=314 +'SCROLL'=315 +'SEARCH'=316 +'SECOND'=317 +'SECURITY'=318 +'SEQUENCE'=319 +'SEQUENCES'=320 +'SERIALIZABLE'=321 +'SERVER'=322 +'SESSION'=323 +'SET'=324 +'SHARE'=325 +'SHOW'=326 +'SIMPLE'=327 +'SNAPSHOT'=328 +'STABLE'=329 +'STANDALONE'=330 +'START'=331 +'STATEMENT'=332 +'STATISTICS'=333 +'STDIN'=334 +'STDOUT'=335 +'STORAGE'=336 +'STRICT'=337 +'STRIP'=338 +'SYSID'=339 +'SYSTEM'=340 +'TABLES'=341 +'TABLESPACE'=342 +'TEMP'=343 +'TEMPLATE'=344 +'TEMPORARY'=345 +'TEXT'=346 +'TRANSACTION'=347 +'TRIGGER'=348 +'TRUNCATE'=349 +'TRUSTED'=350 +'TYPE'=351 +'TYPES'=352 +'UNBOUNDED'=353 +'UNCOMMITTED'=354 +'UNENCRYPTED'=355 +'UNKNOWN'=356 +'UNLISTEN'=357 +'UNLOGGED'=358 +'UNTIL'=359 +'UPDATE'=360 +'VACUUM'=361 +'VALID'=362 +'VALIDATE'=363 +'VALIDATOR'=364 +'VARYING'=365 +'VERSION'=366 +'VIEW'=367 +'VOLATILE'=368 +'WHITESPACE'=369 +'WITHOUT'=370 +'WORK'=371 +'WRAPPER'=372 +'WRITE'=373 +'XML'=374 +'YEAR'=375 +'YES'=376 +'ZONE'=377 +'BETWEEN'=378 +'BIGINT'=379 +'BIT'=380 +'BOOLEAN'=381 +'CHAR'=382 +'CHARACTER'=383 +'COALESCE'=384 +'DEC'=385 +'DECIMAL'=386 +'EXISTS'=387 +'EXTRACT'=388 +'FLOAT'=389 +'GREATEST'=390 +'INOUT'=391 +'INT'=392 +'INTEGER'=393 +'INTERVAL'=394 +'LEAST'=395 +'NATIONAL'=396 +'NCHAR'=397 +'NONE'=398 +'NULLIF'=399 +'NUMERIC'=400 +'OVERLAY'=401 +'POSITION'=402 +'PRECISION'=403 +'REAL'=404 +'ROW'=405 +'SETOF'=406 +'SMALLINT'=407 +'SUBSTRING'=408 +'TIME'=409 +'TIMESTAMP'=410 +'TREAT'=411 +'TRIM'=412 +'VALUES'=413 +'VARCHAR'=414 +'XMLATTRIBUTES'=415 +'XMLCONCAT'=416 +'XMLELEMENT'=417 +'XMLEXISTS'=418 +'XMLFOREST'=419 +'XMLPARSE'=420 +'XMLPI'=421 +'XMLROOT'=422 +'XMLSERIALIZE'=423 +'CALL'=424 +'CURRENT'=425 +'ATTACH'=426 +'DETACH'=427 +'EXPRESSION'=428 +'GENERATED'=429 +'LOGGED'=430 +'STORED'=431 +'INCLUDE'=432 +'ROUTINE'=433 +'TRANSFORM'=434 +'IMPORT'=435 +'POLICY'=436 +'METHOD'=437 +'REFERENCING'=438 +'NEW'=439 +'OLD'=440 +'VALUE'=441 +'SUBSCRIPTION'=442 +'PUBLICATION'=443 +'OUT'=444 +'END'=445 +'ROUTINES'=446 +'SCHEMAS'=447 +'PROCEDURES'=448 +'INPUT'=449 +'SUPPORT'=450 +'PARALLEL'=451 +'SQL'=452 +'DEPENDS'=453 +'OVERRIDING'=454 +'CONFLICT'=455 +'SKIP'=456 +'LOCKED'=457 +'TIES'=458 +'ROLLUP'=459 +'CUBE'=460 +'GROUPING'=461 +'SETS'=462 +'TABLESAMPLE'=463 +'ORDINALITY'=464 +'XMLTABLE'=465 +'COLUMNS'=466 +'XMLNAMESPACES'=467 +'ROWTYPE'=468 +'NORMALIZED'=469 +'WITHIN'=470 +'FILTER'=471 +'GROUPS'=472 +'OTHERS'=473 +'NFC'=474 +'NFD'=475 +'NFKC'=476 +'NFKD'=477 +'UESCAPE'=478 +'VIEWS'=479 +'NORMALIZE'=480 +'DUMP'=481 +'PRINT_STRICT_PARAMS'=482 +'VARIABLE_CONFLICT'=483 +'ERROR'=484 +'USE_VARIABLE'=485 +'USE_COLUMN'=486 +'ALIAS'=487 +'CONSTANT'=488 +'PERFORM'=489 +'GET'=490 +'DIAGNOSTICS'=491 +'STACKED'=492 +'ELSIF'=493 +'WHILE'=494 +'REVERSE'=495 +'FOREACH'=496 +'SLICE'=497 +'EXIT'=498 +'RETURN'=499 +'QUERY'=500 +'RAISE'=501 +'SQLSTATE'=502 +'DEBUG'=503 +'LOG'=504 +'INFO'=505 +'NOTICE'=506 +'WARNING'=507 +'EXCEPTION'=508 +'ASSERT'=509 +'LOOP'=510 +'OPEN'=511 +'\\\\'=545 +'\''=555 diff --git a/src/lib/pgsql/PostgreSQLParserListener.js b/src/lib/pgsql/PostgreSQLParserListener.js new file mode 100644 index 0000000..f290c2e --- /dev/null +++ b/src/lib/pgsql/PostgreSQLParserListener.js @@ -0,0 +1,7305 @@ +// Generated from /Users/salvo/dt-sql-parser2/src/grammar/pgsql/PostgreSQLParser.g4 by ANTLR 4.8 +// jshint ignore: start +var antlr4 = require('antlr4/index'); + +// This class defines a complete listener for a parse tree produced by PostgreSQLParser. +function PostgreSQLParserListener() { + antlr4.tree.ParseTreeListener.call(this); + return this; +} + +PostgreSQLParserListener.prototype = Object.create(antlr4.tree.ParseTreeListener.prototype); +PostgreSQLParserListener.prototype.constructor = PostgreSQLParserListener; + +// Enter a parse tree produced by PostgreSQLParser#root. +PostgreSQLParserListener.prototype.enterRoot = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#root. +PostgreSQLParserListener.prototype.exitRoot = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#plsqlroot. +PostgreSQLParserListener.prototype.enterPlsqlroot = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#plsqlroot. +PostgreSQLParserListener.prototype.exitPlsqlroot = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmtblock. +PostgreSQLParserListener.prototype.enterStmtblock = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmtblock. +PostgreSQLParserListener.prototype.exitStmtblock = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmtmulti. +PostgreSQLParserListener.prototype.enterStmtmulti = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmtmulti. +PostgreSQLParserListener.prototype.exitStmtmulti = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt. +PostgreSQLParserListener.prototype.enterStmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt. +PostgreSQLParserListener.prototype.exitStmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#plsqlconsolecommand. +PostgreSQLParserListener.prototype.enterPlsqlconsolecommand = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#plsqlconsolecommand. +PostgreSQLParserListener.prototype.exitPlsqlconsolecommand = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#callstmt. +PostgreSQLParserListener.prototype.enterCallstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#callstmt. +PostgreSQLParserListener.prototype.exitCallstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createrolestmt. +PostgreSQLParserListener.prototype.enterCreaterolestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createrolestmt. +PostgreSQLParserListener.prototype.exitCreaterolestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_with. +PostgreSQLParserListener.prototype.enterOpt_with = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_with. +PostgreSQLParserListener.prototype.exitOpt_with = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optrolelist. +PostgreSQLParserListener.prototype.enterOptrolelist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optrolelist. +PostgreSQLParserListener.prototype.exitOptrolelist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alteroptrolelist. +PostgreSQLParserListener.prototype.enterAlteroptrolelist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alteroptrolelist. +PostgreSQLParserListener.prototype.exitAlteroptrolelist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alteroptroleelem. +PostgreSQLParserListener.prototype.enterAlteroptroleelem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alteroptroleelem. +PostgreSQLParserListener.prototype.exitAlteroptroleelem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createoptroleelem. +PostgreSQLParserListener.prototype.enterCreateoptroleelem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createoptroleelem. +PostgreSQLParserListener.prototype.exitCreateoptroleelem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createuserstmt. +PostgreSQLParserListener.prototype.enterCreateuserstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createuserstmt. +PostgreSQLParserListener.prototype.exitCreateuserstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterrolestmt. +PostgreSQLParserListener.prototype.enterAlterrolestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterrolestmt. +PostgreSQLParserListener.prototype.exitAlterrolestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_in_database. +PostgreSQLParserListener.prototype.enterOpt_in_database = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_in_database. +PostgreSQLParserListener.prototype.exitOpt_in_database = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterrolesetstmt. +PostgreSQLParserListener.prototype.enterAlterrolesetstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterrolesetstmt. +PostgreSQLParserListener.prototype.exitAlterrolesetstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#droprolestmt. +PostgreSQLParserListener.prototype.enterDroprolestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#droprolestmt. +PostgreSQLParserListener.prototype.exitDroprolestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#creategroupstmt. +PostgreSQLParserListener.prototype.enterCreategroupstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#creategroupstmt. +PostgreSQLParserListener.prototype.exitCreategroupstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altergroupstmt. +PostgreSQLParserListener.prototype.enterAltergroupstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altergroupstmt. +PostgreSQLParserListener.prototype.exitAltergroupstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#add_drop. +PostgreSQLParserListener.prototype.enterAdd_drop = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#add_drop. +PostgreSQLParserListener.prototype.exitAdd_drop = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createschemastmt. +PostgreSQLParserListener.prototype.enterCreateschemastmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createschemastmt. +PostgreSQLParserListener.prototype.exitCreateschemastmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optschemaname. +PostgreSQLParserListener.prototype.enterOptschemaname = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optschemaname. +PostgreSQLParserListener.prototype.exitOptschemaname = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optschemaeltlist. +PostgreSQLParserListener.prototype.enterOptschemaeltlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optschemaeltlist. +PostgreSQLParserListener.prototype.exitOptschemaeltlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#schema_stmt. +PostgreSQLParserListener.prototype.enterSchema_stmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#schema_stmt. +PostgreSQLParserListener.prototype.exitSchema_stmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#variablesetstmt. +PostgreSQLParserListener.prototype.enterVariablesetstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#variablesetstmt. +PostgreSQLParserListener.prototype.exitVariablesetstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#set_rest. +PostgreSQLParserListener.prototype.enterSet_rest = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#set_rest. +PostgreSQLParserListener.prototype.exitSet_rest = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#generic_set. +PostgreSQLParserListener.prototype.enterGeneric_set = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#generic_set. +PostgreSQLParserListener.prototype.exitGeneric_set = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#set_rest_more. +PostgreSQLParserListener.prototype.enterSet_rest_more = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#set_rest_more. +PostgreSQLParserListener.prototype.exitSet_rest_more = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#var_name. +PostgreSQLParserListener.prototype.enterVar_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#var_name. +PostgreSQLParserListener.prototype.exitVar_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#var_list. +PostgreSQLParserListener.prototype.enterVar_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#var_list. +PostgreSQLParserListener.prototype.exitVar_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#var_value. +PostgreSQLParserListener.prototype.enterVar_value = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#var_value. +PostgreSQLParserListener.prototype.exitVar_value = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#iso_level. +PostgreSQLParserListener.prototype.enterIso_level = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#iso_level. +PostgreSQLParserListener.prototype.exitIso_level = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_boolean_or_string. +PostgreSQLParserListener.prototype.enterOpt_boolean_or_string = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_boolean_or_string. +PostgreSQLParserListener.prototype.exitOpt_boolean_or_string = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#zone_value. +PostgreSQLParserListener.prototype.enterZone_value = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#zone_value. +PostgreSQLParserListener.prototype.exitZone_value = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_encoding. +PostgreSQLParserListener.prototype.enterOpt_encoding = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_encoding. +PostgreSQLParserListener.prototype.exitOpt_encoding = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#nonreservedword_or_sconst. +PostgreSQLParserListener.prototype.enterNonreservedword_or_sconst = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#nonreservedword_or_sconst. +PostgreSQLParserListener.prototype.exitNonreservedword_or_sconst = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#variableresetstmt. +PostgreSQLParserListener.prototype.enterVariableresetstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#variableresetstmt. +PostgreSQLParserListener.prototype.exitVariableresetstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reset_rest. +PostgreSQLParserListener.prototype.enterReset_rest = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reset_rest. +PostgreSQLParserListener.prototype.exitReset_rest = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#generic_reset. +PostgreSQLParserListener.prototype.enterGeneric_reset = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#generic_reset. +PostgreSQLParserListener.prototype.exitGeneric_reset = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#setresetclause. +PostgreSQLParserListener.prototype.enterSetresetclause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#setresetclause. +PostgreSQLParserListener.prototype.exitSetresetclause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#functionsetresetclause. +PostgreSQLParserListener.prototype.enterFunctionsetresetclause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#functionsetresetclause. +PostgreSQLParserListener.prototype.exitFunctionsetresetclause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#variableshowstmt. +PostgreSQLParserListener.prototype.enterVariableshowstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#variableshowstmt. +PostgreSQLParserListener.prototype.exitVariableshowstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constraintssetstmt. +PostgreSQLParserListener.prototype.enterConstraintssetstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constraintssetstmt. +PostgreSQLParserListener.prototype.exitConstraintssetstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constraints_set_list. +PostgreSQLParserListener.prototype.enterConstraints_set_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constraints_set_list. +PostgreSQLParserListener.prototype.exitConstraints_set_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constraints_set_mode. +PostgreSQLParserListener.prototype.enterConstraints_set_mode = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constraints_set_mode. +PostgreSQLParserListener.prototype.exitConstraints_set_mode = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#checkpointstmt. +PostgreSQLParserListener.prototype.enterCheckpointstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#checkpointstmt. +PostgreSQLParserListener.prototype.exitCheckpointstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#discardstmt. +PostgreSQLParserListener.prototype.enterDiscardstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#discardstmt. +PostgreSQLParserListener.prototype.exitDiscardstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altertablestmt. +PostgreSQLParserListener.prototype.enterAltertablestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altertablestmt. +PostgreSQLParserListener.prototype.exitAltertablestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_table_cmds. +PostgreSQLParserListener.prototype.enterAlter_table_cmds = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_table_cmds. +PostgreSQLParserListener.prototype.exitAlter_table_cmds = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#partition_cmd. +PostgreSQLParserListener.prototype.enterPartition_cmd = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#partition_cmd. +PostgreSQLParserListener.prototype.exitPartition_cmd = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#index_partition_cmd. +PostgreSQLParserListener.prototype.enterIndex_partition_cmd = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#index_partition_cmd. +PostgreSQLParserListener.prototype.exitIndex_partition_cmd = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_table_cmd. +PostgreSQLParserListener.prototype.enterAlter_table_cmd = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_table_cmd. +PostgreSQLParserListener.prototype.exitAlter_table_cmd = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_column_default. +PostgreSQLParserListener.prototype.enterAlter_column_default = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_column_default. +PostgreSQLParserListener.prototype.exitAlter_column_default = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_drop_behavior. +PostgreSQLParserListener.prototype.enterOpt_drop_behavior = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_drop_behavior. +PostgreSQLParserListener.prototype.exitOpt_drop_behavior = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_collate_clause. +PostgreSQLParserListener.prototype.enterOpt_collate_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_collate_clause. +PostgreSQLParserListener.prototype.exitOpt_collate_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_using. +PostgreSQLParserListener.prototype.enterAlter_using = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_using. +PostgreSQLParserListener.prototype.exitAlter_using = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#replica_identity. +PostgreSQLParserListener.prototype.enterReplica_identity = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#replica_identity. +PostgreSQLParserListener.prototype.exitReplica_identity = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reloptions. +PostgreSQLParserListener.prototype.enterReloptions = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reloptions. +PostgreSQLParserListener.prototype.exitReloptions = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_reloptions. +PostgreSQLParserListener.prototype.enterOpt_reloptions = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_reloptions. +PostgreSQLParserListener.prototype.exitOpt_reloptions = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reloption_list. +PostgreSQLParserListener.prototype.enterReloption_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reloption_list. +PostgreSQLParserListener.prototype.exitReloption_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reloption_elem. +PostgreSQLParserListener.prototype.enterReloption_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reloption_elem. +PostgreSQLParserListener.prototype.exitReloption_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_identity_column_option_list. +PostgreSQLParserListener.prototype.enterAlter_identity_column_option_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_identity_column_option_list. +PostgreSQLParserListener.prototype.exitAlter_identity_column_option_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_identity_column_option. +PostgreSQLParserListener.prototype.enterAlter_identity_column_option = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_identity_column_option. +PostgreSQLParserListener.prototype.exitAlter_identity_column_option = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#partitionboundspec. +PostgreSQLParserListener.prototype.enterPartitionboundspec = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#partitionboundspec. +PostgreSQLParserListener.prototype.exitPartitionboundspec = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#hash_partbound_elem. +PostgreSQLParserListener.prototype.enterHash_partbound_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#hash_partbound_elem. +PostgreSQLParserListener.prototype.exitHash_partbound_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#hash_partbound. +PostgreSQLParserListener.prototype.enterHash_partbound = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#hash_partbound. +PostgreSQLParserListener.prototype.exitHash_partbound = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altercompositetypestmt. +PostgreSQLParserListener.prototype.enterAltercompositetypestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altercompositetypestmt. +PostgreSQLParserListener.prototype.exitAltercompositetypestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_type_cmds. +PostgreSQLParserListener.prototype.enterAlter_type_cmds = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_type_cmds. +PostgreSQLParserListener.prototype.exitAlter_type_cmds = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_type_cmd. +PostgreSQLParserListener.prototype.enterAlter_type_cmd = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_type_cmd. +PostgreSQLParserListener.prototype.exitAlter_type_cmd = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#closeportalstmt. +PostgreSQLParserListener.prototype.enterCloseportalstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#closeportalstmt. +PostgreSQLParserListener.prototype.exitCloseportalstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copystmt. +PostgreSQLParserListener.prototype.enterCopystmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copystmt. +PostgreSQLParserListener.prototype.exitCopystmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_from. +PostgreSQLParserListener.prototype.enterCopy_from = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_from. +PostgreSQLParserListener.prototype.exitCopy_from = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_program. +PostgreSQLParserListener.prototype.enterOpt_program = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_program. +PostgreSQLParserListener.prototype.exitOpt_program = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_file_name. +PostgreSQLParserListener.prototype.enterCopy_file_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_file_name. +PostgreSQLParserListener.prototype.exitCopy_file_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_options. +PostgreSQLParserListener.prototype.enterCopy_options = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_options. +PostgreSQLParserListener.prototype.exitCopy_options = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_opt_list. +PostgreSQLParserListener.prototype.enterCopy_opt_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_opt_list. +PostgreSQLParserListener.prototype.exitCopy_opt_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_opt_item. +PostgreSQLParserListener.prototype.enterCopy_opt_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_opt_item. +PostgreSQLParserListener.prototype.exitCopy_opt_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_binary. +PostgreSQLParserListener.prototype.enterOpt_binary = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_binary. +PostgreSQLParserListener.prototype.exitOpt_binary = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_delimiter. +PostgreSQLParserListener.prototype.enterCopy_delimiter = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_delimiter. +PostgreSQLParserListener.prototype.exitCopy_delimiter = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_using. +PostgreSQLParserListener.prototype.enterOpt_using = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_using. +PostgreSQLParserListener.prototype.exitOpt_using = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_generic_opt_list. +PostgreSQLParserListener.prototype.enterCopy_generic_opt_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_generic_opt_list. +PostgreSQLParserListener.prototype.exitCopy_generic_opt_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_generic_opt_elem. +PostgreSQLParserListener.prototype.enterCopy_generic_opt_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_generic_opt_elem. +PostgreSQLParserListener.prototype.exitCopy_generic_opt_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_generic_opt_arg. +PostgreSQLParserListener.prototype.enterCopy_generic_opt_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_generic_opt_arg. +PostgreSQLParserListener.prototype.exitCopy_generic_opt_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_generic_opt_arg_list. +PostgreSQLParserListener.prototype.enterCopy_generic_opt_arg_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_generic_opt_arg_list. +PostgreSQLParserListener.prototype.exitCopy_generic_opt_arg_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#copy_generic_opt_arg_list_item. +PostgreSQLParserListener.prototype.enterCopy_generic_opt_arg_list_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#copy_generic_opt_arg_list_item. +PostgreSQLParserListener.prototype.exitCopy_generic_opt_arg_list_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createstmt. +PostgreSQLParserListener.prototype.enterCreatestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createstmt. +PostgreSQLParserListener.prototype.exitCreatestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opttemp. +PostgreSQLParserListener.prototype.enterOpttemp = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opttemp. +PostgreSQLParserListener.prototype.exitOpttemp = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opttableelementlist. +PostgreSQLParserListener.prototype.enterOpttableelementlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opttableelementlist. +PostgreSQLParserListener.prototype.exitOpttableelementlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opttypedtableelementlist. +PostgreSQLParserListener.prototype.enterOpttypedtableelementlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opttypedtableelementlist. +PostgreSQLParserListener.prototype.exitOpttypedtableelementlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#tableelementlist. +PostgreSQLParserListener.prototype.enterTableelementlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#tableelementlist. +PostgreSQLParserListener.prototype.exitTableelementlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#typedtableelementlist. +PostgreSQLParserListener.prototype.enterTypedtableelementlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#typedtableelementlist. +PostgreSQLParserListener.prototype.exitTypedtableelementlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#tableelement. +PostgreSQLParserListener.prototype.enterTableelement = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#tableelement. +PostgreSQLParserListener.prototype.exitTableelement = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#typedtableelement. +PostgreSQLParserListener.prototype.enterTypedtableelement = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#typedtableelement. +PostgreSQLParserListener.prototype.exitTypedtableelement = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#columnDef. +PostgreSQLParserListener.prototype.enterColumnDef = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#columnDef. +PostgreSQLParserListener.prototype.exitColumnDef = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#columnOptions. +PostgreSQLParserListener.prototype.enterColumnOptions = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#columnOptions. +PostgreSQLParserListener.prototype.exitColumnOptions = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#colquallist. +PostgreSQLParserListener.prototype.enterColquallist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#colquallist. +PostgreSQLParserListener.prototype.exitColquallist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#colconstraint. +PostgreSQLParserListener.prototype.enterColconstraint = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#colconstraint. +PostgreSQLParserListener.prototype.exitColconstraint = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#colconstraintelem. +PostgreSQLParserListener.prototype.enterColconstraintelem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#colconstraintelem. +PostgreSQLParserListener.prototype.exitColconstraintelem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#generated_when. +PostgreSQLParserListener.prototype.enterGenerated_when = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#generated_when. +PostgreSQLParserListener.prototype.exitGenerated_when = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constraintattr. +PostgreSQLParserListener.prototype.enterConstraintattr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constraintattr. +PostgreSQLParserListener.prototype.exitConstraintattr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#tablelikeclause. +PostgreSQLParserListener.prototype.enterTablelikeclause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#tablelikeclause. +PostgreSQLParserListener.prototype.exitTablelikeclause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#tablelikeoptionlist. +PostgreSQLParserListener.prototype.enterTablelikeoptionlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#tablelikeoptionlist. +PostgreSQLParserListener.prototype.exitTablelikeoptionlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#tablelikeoption. +PostgreSQLParserListener.prototype.enterTablelikeoption = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#tablelikeoption. +PostgreSQLParserListener.prototype.exitTablelikeoption = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#tableconstraint. +PostgreSQLParserListener.prototype.enterTableconstraint = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#tableconstraint. +PostgreSQLParserListener.prototype.exitTableconstraint = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constraintelem. +PostgreSQLParserListener.prototype.enterConstraintelem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constraintelem. +PostgreSQLParserListener.prototype.exitConstraintelem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_no_inherit. +PostgreSQLParserListener.prototype.enterOpt_no_inherit = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_no_inherit. +PostgreSQLParserListener.prototype.exitOpt_no_inherit = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_column_list. +PostgreSQLParserListener.prototype.enterOpt_column_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_column_list. +PostgreSQLParserListener.prototype.exitOpt_column_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#columnlist. +PostgreSQLParserListener.prototype.enterColumnlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#columnlist. +PostgreSQLParserListener.prototype.exitColumnlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#columnElem. +PostgreSQLParserListener.prototype.enterColumnElem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#columnElem. +PostgreSQLParserListener.prototype.exitColumnElem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_c_include. +PostgreSQLParserListener.prototype.enterOpt_c_include = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_c_include. +PostgreSQLParserListener.prototype.exitOpt_c_include = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#key_match. +PostgreSQLParserListener.prototype.enterKey_match = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#key_match. +PostgreSQLParserListener.prototype.exitKey_match = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#exclusionconstraintlist. +PostgreSQLParserListener.prototype.enterExclusionconstraintlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#exclusionconstraintlist. +PostgreSQLParserListener.prototype.exitExclusionconstraintlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#exclusionconstraintelem. +PostgreSQLParserListener.prototype.enterExclusionconstraintelem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#exclusionconstraintelem. +PostgreSQLParserListener.prototype.exitExclusionconstraintelem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#exclusionwhereclause. +PostgreSQLParserListener.prototype.enterExclusionwhereclause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#exclusionwhereclause. +PostgreSQLParserListener.prototype.exitExclusionwhereclause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#key_actions. +PostgreSQLParserListener.prototype.enterKey_actions = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#key_actions. +PostgreSQLParserListener.prototype.exitKey_actions = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#key_update. +PostgreSQLParserListener.prototype.enterKey_update = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#key_update. +PostgreSQLParserListener.prototype.exitKey_update = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#key_delete. +PostgreSQLParserListener.prototype.enterKey_delete = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#key_delete. +PostgreSQLParserListener.prototype.exitKey_delete = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#key_action. +PostgreSQLParserListener.prototype.enterKey_action = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#key_action. +PostgreSQLParserListener.prototype.exitKey_action = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optinherit. +PostgreSQLParserListener.prototype.enterOptinherit = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optinherit. +PostgreSQLParserListener.prototype.exitOptinherit = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optpartitionspec. +PostgreSQLParserListener.prototype.enterOptpartitionspec = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optpartitionspec. +PostgreSQLParserListener.prototype.exitOptpartitionspec = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#partitionspec. +PostgreSQLParserListener.prototype.enterPartitionspec = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#partitionspec. +PostgreSQLParserListener.prototype.exitPartitionspec = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#part_params. +PostgreSQLParserListener.prototype.enterPart_params = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#part_params. +PostgreSQLParserListener.prototype.exitPart_params = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#part_elem. +PostgreSQLParserListener.prototype.enterPart_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#part_elem. +PostgreSQLParserListener.prototype.exitPart_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#table_access_method_clause. +PostgreSQLParserListener.prototype.enterTable_access_method_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#table_access_method_clause. +PostgreSQLParserListener.prototype.exitTable_access_method_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optwith. +PostgreSQLParserListener.prototype.enterOptwith = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optwith. +PostgreSQLParserListener.prototype.exitOptwith = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#oncommitoption. +PostgreSQLParserListener.prototype.enterOncommitoption = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#oncommitoption. +PostgreSQLParserListener.prototype.exitOncommitoption = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opttablespace. +PostgreSQLParserListener.prototype.enterOpttablespace = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opttablespace. +PostgreSQLParserListener.prototype.exitOpttablespace = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optconstablespace. +PostgreSQLParserListener.prototype.enterOptconstablespace = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optconstablespace. +PostgreSQLParserListener.prototype.exitOptconstablespace = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#existingindex. +PostgreSQLParserListener.prototype.enterExistingindex = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#existingindex. +PostgreSQLParserListener.prototype.exitExistingindex = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createstatsstmt. +PostgreSQLParserListener.prototype.enterCreatestatsstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createstatsstmt. +PostgreSQLParserListener.prototype.exitCreatestatsstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterstatsstmt. +PostgreSQLParserListener.prototype.enterAlterstatsstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterstatsstmt. +PostgreSQLParserListener.prototype.exitAlterstatsstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createasstmt. +PostgreSQLParserListener.prototype.enterCreateasstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createasstmt. +PostgreSQLParserListener.prototype.exitCreateasstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#create_as_target. +PostgreSQLParserListener.prototype.enterCreate_as_target = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#create_as_target. +PostgreSQLParserListener.prototype.exitCreate_as_target = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_with_data. +PostgreSQLParserListener.prototype.enterOpt_with_data = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_with_data. +PostgreSQLParserListener.prototype.exitOpt_with_data = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#creatematviewstmt. +PostgreSQLParserListener.prototype.enterCreatematviewstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#creatematviewstmt. +PostgreSQLParserListener.prototype.exitCreatematviewstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#create_mv_target. +PostgreSQLParserListener.prototype.enterCreate_mv_target = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#create_mv_target. +PostgreSQLParserListener.prototype.exitCreate_mv_target = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optnolog. +PostgreSQLParserListener.prototype.enterOptnolog = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optnolog. +PostgreSQLParserListener.prototype.exitOptnolog = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#refreshmatviewstmt. +PostgreSQLParserListener.prototype.enterRefreshmatviewstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#refreshmatviewstmt. +PostgreSQLParserListener.prototype.exitRefreshmatviewstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createseqstmt. +PostgreSQLParserListener.prototype.enterCreateseqstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createseqstmt. +PostgreSQLParserListener.prototype.exitCreateseqstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterseqstmt. +PostgreSQLParserListener.prototype.enterAlterseqstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterseqstmt. +PostgreSQLParserListener.prototype.exitAlterseqstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optseqoptlist. +PostgreSQLParserListener.prototype.enterOptseqoptlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optseqoptlist. +PostgreSQLParserListener.prototype.exitOptseqoptlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optparenthesizedseqoptlist. +PostgreSQLParserListener.prototype.enterOptparenthesizedseqoptlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optparenthesizedseqoptlist. +PostgreSQLParserListener.prototype.exitOptparenthesizedseqoptlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#seqoptlist. +PostgreSQLParserListener.prototype.enterSeqoptlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#seqoptlist. +PostgreSQLParserListener.prototype.exitSeqoptlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#seqoptelem. +PostgreSQLParserListener.prototype.enterSeqoptelem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#seqoptelem. +PostgreSQLParserListener.prototype.exitSeqoptelem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_by. +PostgreSQLParserListener.prototype.enterOpt_by = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_by. +PostgreSQLParserListener.prototype.exitOpt_by = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#numericonly. +PostgreSQLParserListener.prototype.enterNumericonly = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#numericonly. +PostgreSQLParserListener.prototype.exitNumericonly = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#numericonly_list. +PostgreSQLParserListener.prototype.enterNumericonly_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#numericonly_list. +PostgreSQLParserListener.prototype.exitNumericonly_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createplangstmt. +PostgreSQLParserListener.prototype.enterCreateplangstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createplangstmt. +PostgreSQLParserListener.prototype.exitCreateplangstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_trusted. +PostgreSQLParserListener.prototype.enterOpt_trusted = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_trusted. +PostgreSQLParserListener.prototype.exitOpt_trusted = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#handler_name. +PostgreSQLParserListener.prototype.enterHandler_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#handler_name. +PostgreSQLParserListener.prototype.exitHandler_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_inline_handler. +PostgreSQLParserListener.prototype.enterOpt_inline_handler = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_inline_handler. +PostgreSQLParserListener.prototype.exitOpt_inline_handler = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#validator_clause. +PostgreSQLParserListener.prototype.enterValidator_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#validator_clause. +PostgreSQLParserListener.prototype.exitValidator_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_validator. +PostgreSQLParserListener.prototype.enterOpt_validator = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_validator. +PostgreSQLParserListener.prototype.exitOpt_validator = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_procedural. +PostgreSQLParserListener.prototype.enterOpt_procedural = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_procedural. +PostgreSQLParserListener.prototype.exitOpt_procedural = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createtablespacestmt. +PostgreSQLParserListener.prototype.enterCreatetablespacestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createtablespacestmt. +PostgreSQLParserListener.prototype.exitCreatetablespacestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opttablespaceowner. +PostgreSQLParserListener.prototype.enterOpttablespaceowner = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opttablespaceowner. +PostgreSQLParserListener.prototype.exitOpttablespaceowner = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#droptablespacestmt. +PostgreSQLParserListener.prototype.enterDroptablespacestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#droptablespacestmt. +PostgreSQLParserListener.prototype.exitDroptablespacestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createextensionstmt. +PostgreSQLParserListener.prototype.enterCreateextensionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createextensionstmt. +PostgreSQLParserListener.prototype.exitCreateextensionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#create_extension_opt_list. +PostgreSQLParserListener.prototype.enterCreate_extension_opt_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#create_extension_opt_list. +PostgreSQLParserListener.prototype.exitCreate_extension_opt_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#create_extension_opt_item. +PostgreSQLParserListener.prototype.enterCreate_extension_opt_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#create_extension_opt_item. +PostgreSQLParserListener.prototype.exitCreate_extension_opt_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterextensionstmt. +PostgreSQLParserListener.prototype.enterAlterextensionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterextensionstmt. +PostgreSQLParserListener.prototype.exitAlterextensionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_extension_opt_list. +PostgreSQLParserListener.prototype.enterAlter_extension_opt_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_extension_opt_list. +PostgreSQLParserListener.prototype.exitAlter_extension_opt_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_extension_opt_item. +PostgreSQLParserListener.prototype.enterAlter_extension_opt_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_extension_opt_item. +PostgreSQLParserListener.prototype.exitAlter_extension_opt_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterextensioncontentsstmt. +PostgreSQLParserListener.prototype.enterAlterextensioncontentsstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterextensioncontentsstmt. +PostgreSQLParserListener.prototype.exitAlterextensioncontentsstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createfdwstmt. +PostgreSQLParserListener.prototype.enterCreatefdwstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createfdwstmt. +PostgreSQLParserListener.prototype.exitCreatefdwstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#fdw_option. +PostgreSQLParserListener.prototype.enterFdw_option = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#fdw_option. +PostgreSQLParserListener.prototype.exitFdw_option = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#fdw_options. +PostgreSQLParserListener.prototype.enterFdw_options = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#fdw_options. +PostgreSQLParserListener.prototype.exitFdw_options = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_fdw_options. +PostgreSQLParserListener.prototype.enterOpt_fdw_options = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_fdw_options. +PostgreSQLParserListener.prototype.exitOpt_fdw_options = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterfdwstmt. +PostgreSQLParserListener.prototype.enterAlterfdwstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterfdwstmt. +PostgreSQLParserListener.prototype.exitAlterfdwstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#create_generic_options. +PostgreSQLParserListener.prototype.enterCreate_generic_options = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#create_generic_options. +PostgreSQLParserListener.prototype.exitCreate_generic_options = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#generic_option_list. +PostgreSQLParserListener.prototype.enterGeneric_option_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#generic_option_list. +PostgreSQLParserListener.prototype.exitGeneric_option_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_generic_options. +PostgreSQLParserListener.prototype.enterAlter_generic_options = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_generic_options. +PostgreSQLParserListener.prototype.exitAlter_generic_options = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_generic_option_list. +PostgreSQLParserListener.prototype.enterAlter_generic_option_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_generic_option_list. +PostgreSQLParserListener.prototype.exitAlter_generic_option_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alter_generic_option_elem. +PostgreSQLParserListener.prototype.enterAlter_generic_option_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alter_generic_option_elem. +PostgreSQLParserListener.prototype.exitAlter_generic_option_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#generic_option_elem. +PostgreSQLParserListener.prototype.enterGeneric_option_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#generic_option_elem. +PostgreSQLParserListener.prototype.exitGeneric_option_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#generic_option_name. +PostgreSQLParserListener.prototype.enterGeneric_option_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#generic_option_name. +PostgreSQLParserListener.prototype.exitGeneric_option_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#generic_option_arg. +PostgreSQLParserListener.prototype.enterGeneric_option_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#generic_option_arg. +PostgreSQLParserListener.prototype.exitGeneric_option_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createforeignserverstmt. +PostgreSQLParserListener.prototype.enterCreateforeignserverstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createforeignserverstmt. +PostgreSQLParserListener.prototype.exitCreateforeignserverstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_type. +PostgreSQLParserListener.prototype.enterOpt_type = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_type. +PostgreSQLParserListener.prototype.exitOpt_type = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#foreign_server_version. +PostgreSQLParserListener.prototype.enterForeign_server_version = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#foreign_server_version. +PostgreSQLParserListener.prototype.exitForeign_server_version = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_foreign_server_version. +PostgreSQLParserListener.prototype.enterOpt_foreign_server_version = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_foreign_server_version. +PostgreSQLParserListener.prototype.exitOpt_foreign_server_version = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterforeignserverstmt. +PostgreSQLParserListener.prototype.enterAlterforeignserverstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterforeignserverstmt. +PostgreSQLParserListener.prototype.exitAlterforeignserverstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createforeigntablestmt. +PostgreSQLParserListener.prototype.enterCreateforeigntablestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createforeigntablestmt. +PostgreSQLParserListener.prototype.exitCreateforeigntablestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#importforeignschemastmt. +PostgreSQLParserListener.prototype.enterImportforeignschemastmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#importforeignschemastmt. +PostgreSQLParserListener.prototype.exitImportforeignschemastmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#import_qualification_type. +PostgreSQLParserListener.prototype.enterImport_qualification_type = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#import_qualification_type. +PostgreSQLParserListener.prototype.exitImport_qualification_type = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#import_qualification. +PostgreSQLParserListener.prototype.enterImport_qualification = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#import_qualification. +PostgreSQLParserListener.prototype.exitImport_qualification = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createusermappingstmt. +PostgreSQLParserListener.prototype.enterCreateusermappingstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createusermappingstmt. +PostgreSQLParserListener.prototype.exitCreateusermappingstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#auth_ident. +PostgreSQLParserListener.prototype.enterAuth_ident = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#auth_ident. +PostgreSQLParserListener.prototype.exitAuth_ident = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dropusermappingstmt. +PostgreSQLParserListener.prototype.enterDropusermappingstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dropusermappingstmt. +PostgreSQLParserListener.prototype.exitDropusermappingstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterusermappingstmt. +PostgreSQLParserListener.prototype.enterAlterusermappingstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterusermappingstmt. +PostgreSQLParserListener.prototype.exitAlterusermappingstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createpolicystmt. +PostgreSQLParserListener.prototype.enterCreatepolicystmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createpolicystmt. +PostgreSQLParserListener.prototype.exitCreatepolicystmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterpolicystmt. +PostgreSQLParserListener.prototype.enterAlterpolicystmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterpolicystmt. +PostgreSQLParserListener.prototype.exitAlterpolicystmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rowsecurityoptionalexpr. +PostgreSQLParserListener.prototype.enterRowsecurityoptionalexpr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rowsecurityoptionalexpr. +PostgreSQLParserListener.prototype.exitRowsecurityoptionalexpr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rowsecurityoptionalwithcheck. +PostgreSQLParserListener.prototype.enterRowsecurityoptionalwithcheck = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rowsecurityoptionalwithcheck. +PostgreSQLParserListener.prototype.exitRowsecurityoptionalwithcheck = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rowsecuritydefaulttorole. +PostgreSQLParserListener.prototype.enterRowsecuritydefaulttorole = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rowsecuritydefaulttorole. +PostgreSQLParserListener.prototype.exitRowsecuritydefaulttorole = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rowsecurityoptionaltorole. +PostgreSQLParserListener.prototype.enterRowsecurityoptionaltorole = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rowsecurityoptionaltorole. +PostgreSQLParserListener.prototype.exitRowsecurityoptionaltorole = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rowsecuritydefaultpermissive. +PostgreSQLParserListener.prototype.enterRowsecuritydefaultpermissive = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rowsecuritydefaultpermissive. +PostgreSQLParserListener.prototype.exitRowsecuritydefaultpermissive = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rowsecuritydefaultforcmd. +PostgreSQLParserListener.prototype.enterRowsecuritydefaultforcmd = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rowsecuritydefaultforcmd. +PostgreSQLParserListener.prototype.exitRowsecuritydefaultforcmd = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#row_security_cmd. +PostgreSQLParserListener.prototype.enterRow_security_cmd = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#row_security_cmd. +PostgreSQLParserListener.prototype.exitRow_security_cmd = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createamstmt. +PostgreSQLParserListener.prototype.enterCreateamstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createamstmt. +PostgreSQLParserListener.prototype.exitCreateamstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#am_type. +PostgreSQLParserListener.prototype.enterAm_type = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#am_type. +PostgreSQLParserListener.prototype.exitAm_type = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createtrigstmt. +PostgreSQLParserListener.prototype.enterCreatetrigstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createtrigstmt. +PostgreSQLParserListener.prototype.exitCreatetrigstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggeractiontime. +PostgreSQLParserListener.prototype.enterTriggeractiontime = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggeractiontime. +PostgreSQLParserListener.prototype.exitTriggeractiontime = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggerevents. +PostgreSQLParserListener.prototype.enterTriggerevents = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggerevents. +PostgreSQLParserListener.prototype.exitTriggerevents = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggeroneevent. +PostgreSQLParserListener.prototype.enterTriggeroneevent = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggeroneevent. +PostgreSQLParserListener.prototype.exitTriggeroneevent = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggerreferencing. +PostgreSQLParserListener.prototype.enterTriggerreferencing = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggerreferencing. +PostgreSQLParserListener.prototype.exitTriggerreferencing = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggertransitions. +PostgreSQLParserListener.prototype.enterTriggertransitions = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggertransitions. +PostgreSQLParserListener.prototype.exitTriggertransitions = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggertransition. +PostgreSQLParserListener.prototype.enterTriggertransition = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggertransition. +PostgreSQLParserListener.prototype.exitTriggertransition = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#transitionoldornew. +PostgreSQLParserListener.prototype.enterTransitionoldornew = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#transitionoldornew. +PostgreSQLParserListener.prototype.exitTransitionoldornew = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#transitionrowortable. +PostgreSQLParserListener.prototype.enterTransitionrowortable = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#transitionrowortable. +PostgreSQLParserListener.prototype.exitTransitionrowortable = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#transitionrelname. +PostgreSQLParserListener.prototype.enterTransitionrelname = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#transitionrelname. +PostgreSQLParserListener.prototype.exitTransitionrelname = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggerforspec. +PostgreSQLParserListener.prototype.enterTriggerforspec = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggerforspec. +PostgreSQLParserListener.prototype.exitTriggerforspec = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggerforopteach. +PostgreSQLParserListener.prototype.enterTriggerforopteach = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggerforopteach. +PostgreSQLParserListener.prototype.exitTriggerforopteach = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggerfortype. +PostgreSQLParserListener.prototype.enterTriggerfortype = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggerfortype. +PostgreSQLParserListener.prototype.exitTriggerfortype = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggerwhen. +PostgreSQLParserListener.prototype.enterTriggerwhen = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggerwhen. +PostgreSQLParserListener.prototype.exitTriggerwhen = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#function_or_procedure. +PostgreSQLParserListener.prototype.enterFunction_or_procedure = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#function_or_procedure. +PostgreSQLParserListener.prototype.exitFunction_or_procedure = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggerfuncargs. +PostgreSQLParserListener.prototype.enterTriggerfuncargs = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggerfuncargs. +PostgreSQLParserListener.prototype.exitTriggerfuncargs = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#triggerfuncarg. +PostgreSQLParserListener.prototype.enterTriggerfuncarg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#triggerfuncarg. +PostgreSQLParserListener.prototype.exitTriggerfuncarg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#optconstrfromtable. +PostgreSQLParserListener.prototype.enterOptconstrfromtable = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#optconstrfromtable. +PostgreSQLParserListener.prototype.exitOptconstrfromtable = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constraintattributespec. +PostgreSQLParserListener.prototype.enterConstraintattributespec = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constraintattributespec. +PostgreSQLParserListener.prototype.exitConstraintattributespec = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constraintattributeElem. +PostgreSQLParserListener.prototype.enterConstraintattributeElem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constraintattributeElem. +PostgreSQLParserListener.prototype.exitConstraintattributeElem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createeventtrigstmt. +PostgreSQLParserListener.prototype.enterCreateeventtrigstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createeventtrigstmt. +PostgreSQLParserListener.prototype.exitCreateeventtrigstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#event_trigger_when_list. +PostgreSQLParserListener.prototype.enterEvent_trigger_when_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#event_trigger_when_list. +PostgreSQLParserListener.prototype.exitEvent_trigger_when_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#event_trigger_when_item. +PostgreSQLParserListener.prototype.enterEvent_trigger_when_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#event_trigger_when_item. +PostgreSQLParserListener.prototype.exitEvent_trigger_when_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#event_trigger_value_list. +PostgreSQLParserListener.prototype.enterEvent_trigger_value_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#event_trigger_value_list. +PostgreSQLParserListener.prototype.exitEvent_trigger_value_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altereventtrigstmt. +PostgreSQLParserListener.prototype.enterAltereventtrigstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altereventtrigstmt. +PostgreSQLParserListener.prototype.exitAltereventtrigstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#enable_trigger. +PostgreSQLParserListener.prototype.enterEnable_trigger = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#enable_trigger. +PostgreSQLParserListener.prototype.exitEnable_trigger = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createassertionstmt. +PostgreSQLParserListener.prototype.enterCreateassertionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createassertionstmt. +PostgreSQLParserListener.prototype.exitCreateassertionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#definestmt. +PostgreSQLParserListener.prototype.enterDefinestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#definestmt. +PostgreSQLParserListener.prototype.exitDefinestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#definition. +PostgreSQLParserListener.prototype.enterDefinition = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#definition. +PostgreSQLParserListener.prototype.exitDefinition = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#def_list. +PostgreSQLParserListener.prototype.enterDef_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#def_list. +PostgreSQLParserListener.prototype.exitDef_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#def_elem. +PostgreSQLParserListener.prototype.enterDef_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#def_elem. +PostgreSQLParserListener.prototype.exitDef_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#def_arg. +PostgreSQLParserListener.prototype.enterDef_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#def_arg. +PostgreSQLParserListener.prototype.exitDef_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#old_aggr_definition. +PostgreSQLParserListener.prototype.enterOld_aggr_definition = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#old_aggr_definition. +PostgreSQLParserListener.prototype.exitOld_aggr_definition = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#old_aggr_list. +PostgreSQLParserListener.prototype.enterOld_aggr_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#old_aggr_list. +PostgreSQLParserListener.prototype.exitOld_aggr_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#old_aggr_elem. +PostgreSQLParserListener.prototype.enterOld_aggr_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#old_aggr_elem. +PostgreSQLParserListener.prototype.exitOld_aggr_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_enum_val_list. +PostgreSQLParserListener.prototype.enterOpt_enum_val_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_enum_val_list. +PostgreSQLParserListener.prototype.exitOpt_enum_val_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#enum_val_list. +PostgreSQLParserListener.prototype.enterEnum_val_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#enum_val_list. +PostgreSQLParserListener.prototype.exitEnum_val_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterenumstmt. +PostgreSQLParserListener.prototype.enterAlterenumstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterenumstmt. +PostgreSQLParserListener.prototype.exitAlterenumstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_if_not_exists. +PostgreSQLParserListener.prototype.enterOpt_if_not_exists = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_if_not_exists. +PostgreSQLParserListener.prototype.exitOpt_if_not_exists = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createopclassstmt. +PostgreSQLParserListener.prototype.enterCreateopclassstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createopclassstmt. +PostgreSQLParserListener.prototype.exitCreateopclassstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opclass_item_list. +PostgreSQLParserListener.prototype.enterOpclass_item_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opclass_item_list. +PostgreSQLParserListener.prototype.exitOpclass_item_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opclass_item. +PostgreSQLParserListener.prototype.enterOpclass_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opclass_item. +PostgreSQLParserListener.prototype.exitOpclass_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_default. +PostgreSQLParserListener.prototype.enterOpt_default = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_default. +PostgreSQLParserListener.prototype.exitOpt_default = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_opfamily. +PostgreSQLParserListener.prototype.enterOpt_opfamily = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_opfamily. +PostgreSQLParserListener.prototype.exitOpt_opfamily = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opclass_purpose. +PostgreSQLParserListener.prototype.enterOpclass_purpose = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opclass_purpose. +PostgreSQLParserListener.prototype.exitOpclass_purpose = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_recheck. +PostgreSQLParserListener.prototype.enterOpt_recheck = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_recheck. +PostgreSQLParserListener.prototype.exitOpt_recheck = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createopfamilystmt. +PostgreSQLParserListener.prototype.enterCreateopfamilystmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createopfamilystmt. +PostgreSQLParserListener.prototype.exitCreateopfamilystmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alteropfamilystmt. +PostgreSQLParserListener.prototype.enterAlteropfamilystmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alteropfamilystmt. +PostgreSQLParserListener.prototype.exitAlteropfamilystmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opclass_drop_list. +PostgreSQLParserListener.prototype.enterOpclass_drop_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opclass_drop_list. +PostgreSQLParserListener.prototype.exitOpclass_drop_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opclass_drop. +PostgreSQLParserListener.prototype.enterOpclass_drop = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opclass_drop. +PostgreSQLParserListener.prototype.exitOpclass_drop = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dropopclassstmt. +PostgreSQLParserListener.prototype.enterDropopclassstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dropopclassstmt. +PostgreSQLParserListener.prototype.exitDropopclassstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dropopfamilystmt. +PostgreSQLParserListener.prototype.enterDropopfamilystmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dropopfamilystmt. +PostgreSQLParserListener.prototype.exitDropopfamilystmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dropownedstmt. +PostgreSQLParserListener.prototype.enterDropownedstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dropownedstmt. +PostgreSQLParserListener.prototype.exitDropownedstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reassignownedstmt. +PostgreSQLParserListener.prototype.enterReassignownedstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reassignownedstmt. +PostgreSQLParserListener.prototype.exitReassignownedstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dropstmt. +PostgreSQLParserListener.prototype.enterDropstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dropstmt. +PostgreSQLParserListener.prototype.exitDropstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#object_type_any_name. +PostgreSQLParserListener.prototype.enterObject_type_any_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#object_type_any_name. +PostgreSQLParserListener.prototype.exitObject_type_any_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#object_type_name. +PostgreSQLParserListener.prototype.enterObject_type_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#object_type_name. +PostgreSQLParserListener.prototype.exitObject_type_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#drop_type_name. +PostgreSQLParserListener.prototype.enterDrop_type_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#drop_type_name. +PostgreSQLParserListener.prototype.exitDrop_type_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#object_type_name_on_any_name. +PostgreSQLParserListener.prototype.enterObject_type_name_on_any_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#object_type_name_on_any_name. +PostgreSQLParserListener.prototype.exitObject_type_name_on_any_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#any_name_list. +PostgreSQLParserListener.prototype.enterAny_name_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#any_name_list. +PostgreSQLParserListener.prototype.exitAny_name_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#any_name. +PostgreSQLParserListener.prototype.enterAny_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#any_name. +PostgreSQLParserListener.prototype.exitAny_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#attrs. +PostgreSQLParserListener.prototype.enterAttrs = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#attrs. +PostgreSQLParserListener.prototype.exitAttrs = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#type_name_list. +PostgreSQLParserListener.prototype.enterType_name_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#type_name_list. +PostgreSQLParserListener.prototype.exitType_name_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#truncatestmt. +PostgreSQLParserListener.prototype.enterTruncatestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#truncatestmt. +PostgreSQLParserListener.prototype.exitTruncatestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_restart_seqs. +PostgreSQLParserListener.prototype.enterOpt_restart_seqs = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_restart_seqs. +PostgreSQLParserListener.prototype.exitOpt_restart_seqs = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#commentstmt. +PostgreSQLParserListener.prototype.enterCommentstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#commentstmt. +PostgreSQLParserListener.prototype.exitCommentstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#comment_text. +PostgreSQLParserListener.prototype.enterComment_text = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#comment_text. +PostgreSQLParserListener.prototype.exitComment_text = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#seclabelstmt. +PostgreSQLParserListener.prototype.enterSeclabelstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#seclabelstmt. +PostgreSQLParserListener.prototype.exitSeclabelstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_provider. +PostgreSQLParserListener.prototype.enterOpt_provider = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_provider. +PostgreSQLParserListener.prototype.exitOpt_provider = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#security_label. +PostgreSQLParserListener.prototype.enterSecurity_label = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#security_label. +PostgreSQLParserListener.prototype.exitSecurity_label = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#fetchstmt. +PostgreSQLParserListener.prototype.enterFetchstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#fetchstmt. +PostgreSQLParserListener.prototype.exitFetchstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#fetch_args. +PostgreSQLParserListener.prototype.enterFetch_args = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#fetch_args. +PostgreSQLParserListener.prototype.exitFetch_args = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#from_in. +PostgreSQLParserListener.prototype.enterFrom_in = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#from_in. +PostgreSQLParserListener.prototype.exitFrom_in = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_from_in. +PostgreSQLParserListener.prototype.enterOpt_from_in = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_from_in. +PostgreSQLParserListener.prototype.exitOpt_from_in = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#grantstmt. +PostgreSQLParserListener.prototype.enterGrantstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#grantstmt. +PostgreSQLParserListener.prototype.exitGrantstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#revokestmt. +PostgreSQLParserListener.prototype.enterRevokestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#revokestmt. +PostgreSQLParserListener.prototype.exitRevokestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#privileges. +PostgreSQLParserListener.prototype.enterPrivileges = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#privileges. +PostgreSQLParserListener.prototype.exitPrivileges = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#privilege_list. +PostgreSQLParserListener.prototype.enterPrivilege_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#privilege_list. +PostgreSQLParserListener.prototype.exitPrivilege_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#privilege. +PostgreSQLParserListener.prototype.enterPrivilege = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#privilege. +PostgreSQLParserListener.prototype.exitPrivilege = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#privilege_target. +PostgreSQLParserListener.prototype.enterPrivilege_target = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#privilege_target. +PostgreSQLParserListener.prototype.exitPrivilege_target = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#grantee_list. +PostgreSQLParserListener.prototype.enterGrantee_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#grantee_list. +PostgreSQLParserListener.prototype.exitGrantee_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#grantee. +PostgreSQLParserListener.prototype.enterGrantee = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#grantee. +PostgreSQLParserListener.prototype.exitGrantee = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_grant_grant_option. +PostgreSQLParserListener.prototype.enterOpt_grant_grant_option = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_grant_grant_option. +PostgreSQLParserListener.prototype.exitOpt_grant_grant_option = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#grantrolestmt. +PostgreSQLParserListener.prototype.enterGrantrolestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#grantrolestmt. +PostgreSQLParserListener.prototype.exitGrantrolestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#revokerolestmt. +PostgreSQLParserListener.prototype.enterRevokerolestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#revokerolestmt. +PostgreSQLParserListener.prototype.exitRevokerolestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_grant_admin_option. +PostgreSQLParserListener.prototype.enterOpt_grant_admin_option = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_grant_admin_option. +PostgreSQLParserListener.prototype.exitOpt_grant_admin_option = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_granted_by. +PostgreSQLParserListener.prototype.enterOpt_granted_by = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_granted_by. +PostgreSQLParserListener.prototype.exitOpt_granted_by = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterdefaultprivilegesstmt. +PostgreSQLParserListener.prototype.enterAlterdefaultprivilegesstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterdefaultprivilegesstmt. +PostgreSQLParserListener.prototype.exitAlterdefaultprivilegesstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#defacloptionlist. +PostgreSQLParserListener.prototype.enterDefacloptionlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#defacloptionlist. +PostgreSQLParserListener.prototype.exitDefacloptionlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#defacloption. +PostgreSQLParserListener.prototype.enterDefacloption = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#defacloption. +PostgreSQLParserListener.prototype.exitDefacloption = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#defaclaction. +PostgreSQLParserListener.prototype.enterDefaclaction = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#defaclaction. +PostgreSQLParserListener.prototype.exitDefaclaction = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#defacl_privilege_target. +PostgreSQLParserListener.prototype.enterDefacl_privilege_target = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#defacl_privilege_target. +PostgreSQLParserListener.prototype.exitDefacl_privilege_target = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#indexstmt. +PostgreSQLParserListener.prototype.enterIndexstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#indexstmt. +PostgreSQLParserListener.prototype.exitIndexstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_unique. +PostgreSQLParserListener.prototype.enterOpt_unique = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_unique. +PostgreSQLParserListener.prototype.exitOpt_unique = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_concurrently. +PostgreSQLParserListener.prototype.enterOpt_concurrently = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_concurrently. +PostgreSQLParserListener.prototype.exitOpt_concurrently = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_index_name. +PostgreSQLParserListener.prototype.enterOpt_index_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_index_name. +PostgreSQLParserListener.prototype.exitOpt_index_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#access_method_clause. +PostgreSQLParserListener.prototype.enterAccess_method_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#access_method_clause. +PostgreSQLParserListener.prototype.exitAccess_method_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#index_params. +PostgreSQLParserListener.prototype.enterIndex_params = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#index_params. +PostgreSQLParserListener.prototype.exitIndex_params = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#index_elem_options. +PostgreSQLParserListener.prototype.enterIndex_elem_options = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#index_elem_options. +PostgreSQLParserListener.prototype.exitIndex_elem_options = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#index_elem. +PostgreSQLParserListener.prototype.enterIndex_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#index_elem. +PostgreSQLParserListener.prototype.exitIndex_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_include. +PostgreSQLParserListener.prototype.enterOpt_include = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_include. +PostgreSQLParserListener.prototype.exitOpt_include = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#index_including_params. +PostgreSQLParserListener.prototype.enterIndex_including_params = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#index_including_params. +PostgreSQLParserListener.prototype.exitIndex_including_params = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_collate. +PostgreSQLParserListener.prototype.enterOpt_collate = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_collate. +PostgreSQLParserListener.prototype.exitOpt_collate = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_class. +PostgreSQLParserListener.prototype.enterOpt_class = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_class. +PostgreSQLParserListener.prototype.exitOpt_class = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_asc_desc. +PostgreSQLParserListener.prototype.enterOpt_asc_desc = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_asc_desc. +PostgreSQLParserListener.prototype.exitOpt_asc_desc = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_nulls_order. +PostgreSQLParserListener.prototype.enterOpt_nulls_order = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_nulls_order. +PostgreSQLParserListener.prototype.exitOpt_nulls_order = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createfunctionstmt. +PostgreSQLParserListener.prototype.enterCreatefunctionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createfunctionstmt. +PostgreSQLParserListener.prototype.exitCreatefunctionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_or_replace. +PostgreSQLParserListener.prototype.enterOpt_or_replace = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_or_replace. +PostgreSQLParserListener.prototype.exitOpt_or_replace = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_args. +PostgreSQLParserListener.prototype.enterFunc_args = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_args. +PostgreSQLParserListener.prototype.exitFunc_args = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_args_list. +PostgreSQLParserListener.prototype.enterFunc_args_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_args_list. +PostgreSQLParserListener.prototype.exitFunc_args_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#function_with_argtypes_list. +PostgreSQLParserListener.prototype.enterFunction_with_argtypes_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#function_with_argtypes_list. +PostgreSQLParserListener.prototype.exitFunction_with_argtypes_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#function_with_argtypes. +PostgreSQLParserListener.prototype.enterFunction_with_argtypes = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#function_with_argtypes. +PostgreSQLParserListener.prototype.exitFunction_with_argtypes = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_args_with_defaults. +PostgreSQLParserListener.prototype.enterFunc_args_with_defaults = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_args_with_defaults. +PostgreSQLParserListener.prototype.exitFunc_args_with_defaults = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_args_with_defaults_list. +PostgreSQLParserListener.prototype.enterFunc_args_with_defaults_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_args_with_defaults_list. +PostgreSQLParserListener.prototype.exitFunc_args_with_defaults_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_arg. +PostgreSQLParserListener.prototype.enterFunc_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_arg. +PostgreSQLParserListener.prototype.exitFunc_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#arg_class. +PostgreSQLParserListener.prototype.enterArg_class = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#arg_class. +PostgreSQLParserListener.prototype.exitArg_class = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#param_name. +PostgreSQLParserListener.prototype.enterParam_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#param_name. +PostgreSQLParserListener.prototype.exitParam_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_return. +PostgreSQLParserListener.prototype.enterFunc_return = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_return. +PostgreSQLParserListener.prototype.exitFunc_return = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_type. +PostgreSQLParserListener.prototype.enterFunc_type = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_type. +PostgreSQLParserListener.prototype.exitFunc_type = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_arg_with_default. +PostgreSQLParserListener.prototype.enterFunc_arg_with_default = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_arg_with_default. +PostgreSQLParserListener.prototype.exitFunc_arg_with_default = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#aggr_arg. +PostgreSQLParserListener.prototype.enterAggr_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#aggr_arg. +PostgreSQLParserListener.prototype.exitAggr_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#aggr_args. +PostgreSQLParserListener.prototype.enterAggr_args = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#aggr_args. +PostgreSQLParserListener.prototype.exitAggr_args = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#aggr_args_list. +PostgreSQLParserListener.prototype.enterAggr_args_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#aggr_args_list. +PostgreSQLParserListener.prototype.exitAggr_args_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#aggregate_with_argtypes. +PostgreSQLParserListener.prototype.enterAggregate_with_argtypes = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#aggregate_with_argtypes. +PostgreSQLParserListener.prototype.exitAggregate_with_argtypes = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#aggregate_with_argtypes_list. +PostgreSQLParserListener.prototype.enterAggregate_with_argtypes_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#aggregate_with_argtypes_list. +PostgreSQLParserListener.prototype.exitAggregate_with_argtypes_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createfunc_opt_list. +PostgreSQLParserListener.prototype.enterCreatefunc_opt_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createfunc_opt_list. +PostgreSQLParserListener.prototype.exitCreatefunc_opt_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#common_func_opt_item. +PostgreSQLParserListener.prototype.enterCommon_func_opt_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#common_func_opt_item. +PostgreSQLParserListener.prototype.exitCommon_func_opt_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createfunc_opt_item. +PostgreSQLParserListener.prototype.enterCreatefunc_opt_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createfunc_opt_item. +PostgreSQLParserListener.prototype.exitCreatefunc_opt_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_as. +PostgreSQLParserListener.prototype.enterFunc_as = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_as. +PostgreSQLParserListener.prototype.exitFunc_as = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#transform_type_list. +PostgreSQLParserListener.prototype.enterTransform_type_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#transform_type_list. +PostgreSQLParserListener.prototype.exitTransform_type_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_definition. +PostgreSQLParserListener.prototype.enterOpt_definition = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_definition. +PostgreSQLParserListener.prototype.exitOpt_definition = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#table_func_column. +PostgreSQLParserListener.prototype.enterTable_func_column = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#table_func_column. +PostgreSQLParserListener.prototype.exitTable_func_column = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#table_func_column_list. +PostgreSQLParserListener.prototype.enterTable_func_column_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#table_func_column_list. +PostgreSQLParserListener.prototype.exitTable_func_column_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterfunctionstmt. +PostgreSQLParserListener.prototype.enterAlterfunctionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterfunctionstmt. +PostgreSQLParserListener.prototype.exitAlterfunctionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterfunc_opt_list. +PostgreSQLParserListener.prototype.enterAlterfunc_opt_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterfunc_opt_list. +PostgreSQLParserListener.prototype.exitAlterfunc_opt_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_restrict. +PostgreSQLParserListener.prototype.enterOpt_restrict = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_restrict. +PostgreSQLParserListener.prototype.exitOpt_restrict = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#removefuncstmt. +PostgreSQLParserListener.prototype.enterRemovefuncstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#removefuncstmt. +PostgreSQLParserListener.prototype.exitRemovefuncstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#removeaggrstmt. +PostgreSQLParserListener.prototype.enterRemoveaggrstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#removeaggrstmt. +PostgreSQLParserListener.prototype.exitRemoveaggrstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#removeoperstmt. +PostgreSQLParserListener.prototype.enterRemoveoperstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#removeoperstmt. +PostgreSQLParserListener.prototype.exitRemoveoperstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#oper_argtypes. +PostgreSQLParserListener.prototype.enterOper_argtypes = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#oper_argtypes. +PostgreSQLParserListener.prototype.exitOper_argtypes = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#any_operator. +PostgreSQLParserListener.prototype.enterAny_operator = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#any_operator. +PostgreSQLParserListener.prototype.exitAny_operator = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#operator_with_argtypes_list. +PostgreSQLParserListener.prototype.enterOperator_with_argtypes_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#operator_with_argtypes_list. +PostgreSQLParserListener.prototype.exitOperator_with_argtypes_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#operator_with_argtypes. +PostgreSQLParserListener.prototype.enterOperator_with_argtypes = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#operator_with_argtypes. +PostgreSQLParserListener.prototype.exitOperator_with_argtypes = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dostmt. +PostgreSQLParserListener.prototype.enterDostmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dostmt. +PostgreSQLParserListener.prototype.exitDostmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dostmt_opt_list. +PostgreSQLParserListener.prototype.enterDostmt_opt_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dostmt_opt_list. +PostgreSQLParserListener.prototype.exitDostmt_opt_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dostmt_opt_item. +PostgreSQLParserListener.prototype.enterDostmt_opt_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dostmt_opt_item. +PostgreSQLParserListener.prototype.exitDostmt_opt_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createcaststmt. +PostgreSQLParserListener.prototype.enterCreatecaststmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createcaststmt. +PostgreSQLParserListener.prototype.exitCreatecaststmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#cast_context. +PostgreSQLParserListener.prototype.enterCast_context = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#cast_context. +PostgreSQLParserListener.prototype.exitCast_context = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dropcaststmt. +PostgreSQLParserListener.prototype.enterDropcaststmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dropcaststmt. +PostgreSQLParserListener.prototype.exitDropcaststmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_if_exists. +PostgreSQLParserListener.prototype.enterOpt_if_exists = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_if_exists. +PostgreSQLParserListener.prototype.exitOpt_if_exists = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createtransformstmt. +PostgreSQLParserListener.prototype.enterCreatetransformstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createtransformstmt. +PostgreSQLParserListener.prototype.exitCreatetransformstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#transform_element_list. +PostgreSQLParserListener.prototype.enterTransform_element_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#transform_element_list. +PostgreSQLParserListener.prototype.exitTransform_element_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#droptransformstmt. +PostgreSQLParserListener.prototype.enterDroptransformstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#droptransformstmt. +PostgreSQLParserListener.prototype.exitDroptransformstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reindexstmt. +PostgreSQLParserListener.prototype.enterReindexstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reindexstmt. +PostgreSQLParserListener.prototype.exitReindexstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reindex_target_type. +PostgreSQLParserListener.prototype.enterReindex_target_type = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reindex_target_type. +PostgreSQLParserListener.prototype.exitReindex_target_type = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reindex_target_multitable. +PostgreSQLParserListener.prototype.enterReindex_target_multitable = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reindex_target_multitable. +PostgreSQLParserListener.prototype.exitReindex_target_multitable = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reindex_option_list. +PostgreSQLParserListener.prototype.enterReindex_option_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reindex_option_list. +PostgreSQLParserListener.prototype.exitReindex_option_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reindex_option_elem. +PostgreSQLParserListener.prototype.enterReindex_option_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reindex_option_elem. +PostgreSQLParserListener.prototype.exitReindex_option_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altertblspcstmt. +PostgreSQLParserListener.prototype.enterAltertblspcstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altertblspcstmt. +PostgreSQLParserListener.prototype.exitAltertblspcstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#renamestmt. +PostgreSQLParserListener.prototype.enterRenamestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#renamestmt. +PostgreSQLParserListener.prototype.exitRenamestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_column. +PostgreSQLParserListener.prototype.enterOpt_column = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_column. +PostgreSQLParserListener.prototype.exitOpt_column = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_set_data. +PostgreSQLParserListener.prototype.enterOpt_set_data = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_set_data. +PostgreSQLParserListener.prototype.exitOpt_set_data = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterobjectdependsstmt. +PostgreSQLParserListener.prototype.enterAlterobjectdependsstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterobjectdependsstmt. +PostgreSQLParserListener.prototype.exitAlterobjectdependsstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_no. +PostgreSQLParserListener.prototype.enterOpt_no = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_no. +PostgreSQLParserListener.prototype.exitOpt_no = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterobjectschemastmt. +PostgreSQLParserListener.prototype.enterAlterobjectschemastmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterobjectschemastmt. +PostgreSQLParserListener.prototype.exitAlterobjectschemastmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alteroperatorstmt. +PostgreSQLParserListener.prototype.enterAlteroperatorstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alteroperatorstmt. +PostgreSQLParserListener.prototype.exitAlteroperatorstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#operator_def_list. +PostgreSQLParserListener.prototype.enterOperator_def_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#operator_def_list. +PostgreSQLParserListener.prototype.exitOperator_def_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#operator_def_elem. +PostgreSQLParserListener.prototype.enterOperator_def_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#operator_def_elem. +PostgreSQLParserListener.prototype.exitOperator_def_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#operator_def_arg. +PostgreSQLParserListener.prototype.enterOperator_def_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#operator_def_arg. +PostgreSQLParserListener.prototype.exitOperator_def_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altertypestmt. +PostgreSQLParserListener.prototype.enterAltertypestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altertypestmt. +PostgreSQLParserListener.prototype.exitAltertypestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterownerstmt. +PostgreSQLParserListener.prototype.enterAlterownerstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterownerstmt. +PostgreSQLParserListener.prototype.exitAlterownerstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createpublicationstmt. +PostgreSQLParserListener.prototype.enterCreatepublicationstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createpublicationstmt. +PostgreSQLParserListener.prototype.exitCreatepublicationstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_publication_for_tables. +PostgreSQLParserListener.prototype.enterOpt_publication_for_tables = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_publication_for_tables. +PostgreSQLParserListener.prototype.exitOpt_publication_for_tables = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#publication_for_tables. +PostgreSQLParserListener.prototype.enterPublication_for_tables = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#publication_for_tables. +PostgreSQLParserListener.prototype.exitPublication_for_tables = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterpublicationstmt. +PostgreSQLParserListener.prototype.enterAlterpublicationstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterpublicationstmt. +PostgreSQLParserListener.prototype.exitAlterpublicationstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createsubscriptionstmt. +PostgreSQLParserListener.prototype.enterCreatesubscriptionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createsubscriptionstmt. +PostgreSQLParserListener.prototype.exitCreatesubscriptionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#publication_name_list. +PostgreSQLParserListener.prototype.enterPublication_name_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#publication_name_list. +PostgreSQLParserListener.prototype.exitPublication_name_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#publication_name_item. +PostgreSQLParserListener.prototype.enterPublication_name_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#publication_name_item. +PostgreSQLParserListener.prototype.exitPublication_name_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altersubscriptionstmt. +PostgreSQLParserListener.prototype.enterAltersubscriptionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altersubscriptionstmt. +PostgreSQLParserListener.prototype.exitAltersubscriptionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dropsubscriptionstmt. +PostgreSQLParserListener.prototype.enterDropsubscriptionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dropsubscriptionstmt. +PostgreSQLParserListener.prototype.exitDropsubscriptionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rulestmt. +PostgreSQLParserListener.prototype.enterRulestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rulestmt. +PostgreSQLParserListener.prototype.exitRulestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#ruleactionlist. +PostgreSQLParserListener.prototype.enterRuleactionlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#ruleactionlist. +PostgreSQLParserListener.prototype.exitRuleactionlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#ruleactionmulti. +PostgreSQLParserListener.prototype.enterRuleactionmulti = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#ruleactionmulti. +PostgreSQLParserListener.prototype.exitRuleactionmulti = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#ruleactionstmt. +PostgreSQLParserListener.prototype.enterRuleactionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#ruleactionstmt. +PostgreSQLParserListener.prototype.exitRuleactionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#ruleactionstmtOrEmpty. +PostgreSQLParserListener.prototype.enterRuleactionstmtOrEmpty = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#ruleactionstmtOrEmpty. +PostgreSQLParserListener.prototype.exitRuleactionstmtOrEmpty = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#event. +PostgreSQLParserListener.prototype.enterEvent = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#event. +PostgreSQLParserListener.prototype.exitEvent = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_instead. +PostgreSQLParserListener.prototype.enterOpt_instead = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_instead. +PostgreSQLParserListener.prototype.exitOpt_instead = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#notifystmt. +PostgreSQLParserListener.prototype.enterNotifystmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#notifystmt. +PostgreSQLParserListener.prototype.exitNotifystmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#notify_payload. +PostgreSQLParserListener.prototype.enterNotify_payload = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#notify_payload. +PostgreSQLParserListener.prototype.exitNotify_payload = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#listenstmt. +PostgreSQLParserListener.prototype.enterListenstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#listenstmt. +PostgreSQLParserListener.prototype.exitListenstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#unlistenstmt. +PostgreSQLParserListener.prototype.enterUnlistenstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#unlistenstmt. +PostgreSQLParserListener.prototype.exitUnlistenstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#transactionstmt. +PostgreSQLParserListener.prototype.enterTransactionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#transactionstmt. +PostgreSQLParserListener.prototype.exitTransactionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_transaction. +PostgreSQLParserListener.prototype.enterOpt_transaction = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_transaction. +PostgreSQLParserListener.prototype.exitOpt_transaction = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#transaction_mode_item. +PostgreSQLParserListener.prototype.enterTransaction_mode_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#transaction_mode_item. +PostgreSQLParserListener.prototype.exitTransaction_mode_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#transaction_mode_list. +PostgreSQLParserListener.prototype.enterTransaction_mode_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#transaction_mode_list. +PostgreSQLParserListener.prototype.exitTransaction_mode_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#transaction_mode_list_or_empty. +PostgreSQLParserListener.prototype.enterTransaction_mode_list_or_empty = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#transaction_mode_list_or_empty. +PostgreSQLParserListener.prototype.exitTransaction_mode_list_or_empty = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_transaction_chain. +PostgreSQLParserListener.prototype.enterOpt_transaction_chain = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_transaction_chain. +PostgreSQLParserListener.prototype.exitOpt_transaction_chain = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#viewstmt. +PostgreSQLParserListener.prototype.enterViewstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#viewstmt. +PostgreSQLParserListener.prototype.exitViewstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_check_option. +PostgreSQLParserListener.prototype.enterOpt_check_option = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_check_option. +PostgreSQLParserListener.prototype.exitOpt_check_option = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#loadstmt. +PostgreSQLParserListener.prototype.enterLoadstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#loadstmt. +PostgreSQLParserListener.prototype.exitLoadstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createdbstmt. +PostgreSQLParserListener.prototype.enterCreatedbstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createdbstmt. +PostgreSQLParserListener.prototype.exitCreatedbstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createdb_opt_list. +PostgreSQLParserListener.prototype.enterCreatedb_opt_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createdb_opt_list. +PostgreSQLParserListener.prototype.exitCreatedb_opt_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createdb_opt_items. +PostgreSQLParserListener.prototype.enterCreatedb_opt_items = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createdb_opt_items. +PostgreSQLParserListener.prototype.exitCreatedb_opt_items = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createdb_opt_item. +PostgreSQLParserListener.prototype.enterCreatedb_opt_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createdb_opt_item. +PostgreSQLParserListener.prototype.exitCreatedb_opt_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createdb_opt_name. +PostgreSQLParserListener.prototype.enterCreatedb_opt_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createdb_opt_name. +PostgreSQLParserListener.prototype.exitCreatedb_opt_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_equal. +PostgreSQLParserListener.prototype.enterOpt_equal = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_equal. +PostgreSQLParserListener.prototype.exitOpt_equal = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterdatabasestmt. +PostgreSQLParserListener.prototype.enterAlterdatabasestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterdatabasestmt. +PostgreSQLParserListener.prototype.exitAlterdatabasestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterdatabasesetstmt. +PostgreSQLParserListener.prototype.enterAlterdatabasesetstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterdatabasesetstmt. +PostgreSQLParserListener.prototype.exitAlterdatabasesetstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#dropdbstmt. +PostgreSQLParserListener.prototype.enterDropdbstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#dropdbstmt. +PostgreSQLParserListener.prototype.exitDropdbstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#drop_option_list. +PostgreSQLParserListener.prototype.enterDrop_option_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#drop_option_list. +PostgreSQLParserListener.prototype.exitDrop_option_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#drop_option. +PostgreSQLParserListener.prototype.enterDrop_option = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#drop_option. +PostgreSQLParserListener.prototype.exitDrop_option = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altercollationstmt. +PostgreSQLParserListener.prototype.enterAltercollationstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altercollationstmt. +PostgreSQLParserListener.prototype.exitAltercollationstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altersystemstmt. +PostgreSQLParserListener.prototype.enterAltersystemstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altersystemstmt. +PostgreSQLParserListener.prototype.exitAltersystemstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createdomainstmt. +PostgreSQLParserListener.prototype.enterCreatedomainstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createdomainstmt. +PostgreSQLParserListener.prototype.exitCreatedomainstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alterdomainstmt. +PostgreSQLParserListener.prototype.enterAlterdomainstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alterdomainstmt. +PostgreSQLParserListener.prototype.exitAlterdomainstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_as. +PostgreSQLParserListener.prototype.enterOpt_as = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_as. +PostgreSQLParserListener.prototype.exitOpt_as = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altertsdictionarystmt. +PostgreSQLParserListener.prototype.enterAltertsdictionarystmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altertsdictionarystmt. +PostgreSQLParserListener.prototype.exitAltertsdictionarystmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#altertsconfigurationstmt. +PostgreSQLParserListener.prototype.enterAltertsconfigurationstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#altertsconfigurationstmt. +PostgreSQLParserListener.prototype.exitAltertsconfigurationstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#any_with. +PostgreSQLParserListener.prototype.enterAny_with = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#any_with. +PostgreSQLParserListener.prototype.exitAny_with = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#createconversionstmt. +PostgreSQLParserListener.prototype.enterCreateconversionstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#createconversionstmt. +PostgreSQLParserListener.prototype.exitCreateconversionstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#clusterstmt. +PostgreSQLParserListener.prototype.enterClusterstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#clusterstmt. +PostgreSQLParserListener.prototype.exitClusterstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#cluster_index_specification. +PostgreSQLParserListener.prototype.enterCluster_index_specification = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#cluster_index_specification. +PostgreSQLParserListener.prototype.exitCluster_index_specification = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#vacuumstmt. +PostgreSQLParserListener.prototype.enterVacuumstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#vacuumstmt. +PostgreSQLParserListener.prototype.exitVacuumstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#analyzestmt. +PostgreSQLParserListener.prototype.enterAnalyzestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#analyzestmt. +PostgreSQLParserListener.prototype.exitAnalyzestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#vac_analyze_option_list. +PostgreSQLParserListener.prototype.enterVac_analyze_option_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#vac_analyze_option_list. +PostgreSQLParserListener.prototype.exitVac_analyze_option_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#analyze_keyword. +PostgreSQLParserListener.prototype.enterAnalyze_keyword = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#analyze_keyword. +PostgreSQLParserListener.prototype.exitAnalyze_keyword = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#vac_analyze_option_elem. +PostgreSQLParserListener.prototype.enterVac_analyze_option_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#vac_analyze_option_elem. +PostgreSQLParserListener.prototype.exitVac_analyze_option_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#vac_analyze_option_name. +PostgreSQLParserListener.prototype.enterVac_analyze_option_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#vac_analyze_option_name. +PostgreSQLParserListener.prototype.exitVac_analyze_option_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#vac_analyze_option_arg. +PostgreSQLParserListener.prototype.enterVac_analyze_option_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#vac_analyze_option_arg. +PostgreSQLParserListener.prototype.exitVac_analyze_option_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_analyze. +PostgreSQLParserListener.prototype.enterOpt_analyze = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_analyze. +PostgreSQLParserListener.prototype.exitOpt_analyze = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_verbose. +PostgreSQLParserListener.prototype.enterOpt_verbose = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_verbose. +PostgreSQLParserListener.prototype.exitOpt_verbose = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_full. +PostgreSQLParserListener.prototype.enterOpt_full = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_full. +PostgreSQLParserListener.prototype.exitOpt_full = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_freeze. +PostgreSQLParserListener.prototype.enterOpt_freeze = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_freeze. +PostgreSQLParserListener.prototype.exitOpt_freeze = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_name_list. +PostgreSQLParserListener.prototype.enterOpt_name_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_name_list. +PostgreSQLParserListener.prototype.exitOpt_name_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#vacuum_relation. +PostgreSQLParserListener.prototype.enterVacuum_relation = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#vacuum_relation. +PostgreSQLParserListener.prototype.exitVacuum_relation = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#vacuum_relation_list. +PostgreSQLParserListener.prototype.enterVacuum_relation_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#vacuum_relation_list. +PostgreSQLParserListener.prototype.exitVacuum_relation_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_vacuum_relation_list. +PostgreSQLParserListener.prototype.enterOpt_vacuum_relation_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_vacuum_relation_list. +PostgreSQLParserListener.prototype.exitOpt_vacuum_relation_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#explainstmt. +PostgreSQLParserListener.prototype.enterExplainstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#explainstmt. +PostgreSQLParserListener.prototype.exitExplainstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#explainablestmt. +PostgreSQLParserListener.prototype.enterExplainablestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#explainablestmt. +PostgreSQLParserListener.prototype.exitExplainablestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#explain_option_list. +PostgreSQLParserListener.prototype.enterExplain_option_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#explain_option_list. +PostgreSQLParserListener.prototype.exitExplain_option_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#explain_option_elem. +PostgreSQLParserListener.prototype.enterExplain_option_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#explain_option_elem. +PostgreSQLParserListener.prototype.exitExplain_option_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#explain_option_name. +PostgreSQLParserListener.prototype.enterExplain_option_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#explain_option_name. +PostgreSQLParserListener.prototype.exitExplain_option_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#explain_option_arg. +PostgreSQLParserListener.prototype.enterExplain_option_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#explain_option_arg. +PostgreSQLParserListener.prototype.exitExplain_option_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#preparestmt. +PostgreSQLParserListener.prototype.enterPreparestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#preparestmt. +PostgreSQLParserListener.prototype.exitPreparestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#prep_type_clause. +PostgreSQLParserListener.prototype.enterPrep_type_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#prep_type_clause. +PostgreSQLParserListener.prototype.exitPrep_type_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#preparablestmt. +PostgreSQLParserListener.prototype.enterPreparablestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#preparablestmt. +PostgreSQLParserListener.prototype.exitPreparablestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#executestmt. +PostgreSQLParserListener.prototype.enterExecutestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#executestmt. +PostgreSQLParserListener.prototype.exitExecutestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#execute_param_clause. +PostgreSQLParserListener.prototype.enterExecute_param_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#execute_param_clause. +PostgreSQLParserListener.prototype.exitExecute_param_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#deallocatestmt. +PostgreSQLParserListener.prototype.enterDeallocatestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#deallocatestmt. +PostgreSQLParserListener.prototype.exitDeallocatestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#insertstmt. +PostgreSQLParserListener.prototype.enterInsertstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#insertstmt. +PostgreSQLParserListener.prototype.exitInsertstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#insert_target. +PostgreSQLParserListener.prototype.enterInsert_target = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#insert_target. +PostgreSQLParserListener.prototype.exitInsert_target = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#insert_rest. +PostgreSQLParserListener.prototype.enterInsert_rest = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#insert_rest. +PostgreSQLParserListener.prototype.exitInsert_rest = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#override_kind. +PostgreSQLParserListener.prototype.enterOverride_kind = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#override_kind. +PostgreSQLParserListener.prototype.exitOverride_kind = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#insert_column_list. +PostgreSQLParserListener.prototype.enterInsert_column_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#insert_column_list. +PostgreSQLParserListener.prototype.exitInsert_column_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#insert_column_item. +PostgreSQLParserListener.prototype.enterInsert_column_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#insert_column_item. +PostgreSQLParserListener.prototype.exitInsert_column_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_on_conflict. +PostgreSQLParserListener.prototype.enterOpt_on_conflict = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_on_conflict. +PostgreSQLParserListener.prototype.exitOpt_on_conflict = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_conf_expr. +PostgreSQLParserListener.prototype.enterOpt_conf_expr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_conf_expr. +PostgreSQLParserListener.prototype.exitOpt_conf_expr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#returning_clause. +PostgreSQLParserListener.prototype.enterReturning_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#returning_clause. +PostgreSQLParserListener.prototype.exitReturning_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#deletestmt. +PostgreSQLParserListener.prototype.enterDeletestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#deletestmt. +PostgreSQLParserListener.prototype.exitDeletestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#using_clause. +PostgreSQLParserListener.prototype.enterUsing_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#using_clause. +PostgreSQLParserListener.prototype.exitUsing_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#lockstmt. +PostgreSQLParserListener.prototype.enterLockstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#lockstmt. +PostgreSQLParserListener.prototype.exitLockstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_lock. +PostgreSQLParserListener.prototype.enterOpt_lock = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_lock. +PostgreSQLParserListener.prototype.exitOpt_lock = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#lock_type. +PostgreSQLParserListener.prototype.enterLock_type = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#lock_type. +PostgreSQLParserListener.prototype.exitLock_type = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_nowait. +PostgreSQLParserListener.prototype.enterOpt_nowait = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_nowait. +PostgreSQLParserListener.prototype.exitOpt_nowait = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_nowait_or_skip. +PostgreSQLParserListener.prototype.enterOpt_nowait_or_skip = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_nowait_or_skip. +PostgreSQLParserListener.prototype.exitOpt_nowait_or_skip = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#updatestmt. +PostgreSQLParserListener.prototype.enterUpdatestmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#updatestmt. +PostgreSQLParserListener.prototype.exitUpdatestmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#set_clause_list. +PostgreSQLParserListener.prototype.enterSet_clause_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#set_clause_list. +PostgreSQLParserListener.prototype.exitSet_clause_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#set_clause. +PostgreSQLParserListener.prototype.enterSet_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#set_clause. +PostgreSQLParserListener.prototype.exitSet_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#set_target. +PostgreSQLParserListener.prototype.enterSet_target = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#set_target. +PostgreSQLParserListener.prototype.exitSet_target = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#set_target_list. +PostgreSQLParserListener.prototype.enterSet_target_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#set_target_list. +PostgreSQLParserListener.prototype.exitSet_target_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#declarecursorstmt. +PostgreSQLParserListener.prototype.enterDeclarecursorstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#declarecursorstmt. +PostgreSQLParserListener.prototype.exitDeclarecursorstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#cursor_name. +PostgreSQLParserListener.prototype.enterCursor_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#cursor_name. +PostgreSQLParserListener.prototype.exitCursor_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#cursor_options. +PostgreSQLParserListener.prototype.enterCursor_options = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#cursor_options. +PostgreSQLParserListener.prototype.exitCursor_options = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_hold. +PostgreSQLParserListener.prototype.enterOpt_hold = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_hold. +PostgreSQLParserListener.prototype.exitOpt_hold = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#selectstmt. +PostgreSQLParserListener.prototype.enterSelectstmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#selectstmt. +PostgreSQLParserListener.prototype.exitSelectstmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#select_with_parens. +PostgreSQLParserListener.prototype.enterSelect_with_parens = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#select_with_parens. +PostgreSQLParserListener.prototype.exitSelect_with_parens = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#select_no_parens. +PostgreSQLParserListener.prototype.enterSelect_no_parens = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#select_no_parens. +PostgreSQLParserListener.prototype.exitSelect_no_parens = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#select_clause. +PostgreSQLParserListener.prototype.enterSelect_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#select_clause. +PostgreSQLParserListener.prototype.exitSelect_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#simple_select. +PostgreSQLParserListener.prototype.enterSimple_select = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#simple_select. +PostgreSQLParserListener.prototype.exitSimple_select = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#union. +PostgreSQLParserListener.prototype.enterUnion = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#union. +PostgreSQLParserListener.prototype.exitUnion = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#intersect. +PostgreSQLParserListener.prototype.enterIntersect = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#intersect. +PostgreSQLParserListener.prototype.exitIntersect = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#except. +PostgreSQLParserListener.prototype.enterExcept = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#except. +PostgreSQLParserListener.prototype.exitExcept = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#set_operator_with_all_or_distinct. +PostgreSQLParserListener.prototype.enterSet_operator_with_all_or_distinct = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#set_operator_with_all_or_distinct. +PostgreSQLParserListener.prototype.exitSet_operator_with_all_or_distinct = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#with_clause. +PostgreSQLParserListener.prototype.enterWith_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#with_clause. +PostgreSQLParserListener.prototype.exitWith_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#cte_list. +PostgreSQLParserListener.prototype.enterCte_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#cte_list. +PostgreSQLParserListener.prototype.exitCte_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#common_table_expr. +PostgreSQLParserListener.prototype.enterCommon_table_expr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#common_table_expr. +PostgreSQLParserListener.prototype.exitCommon_table_expr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_materialized. +PostgreSQLParserListener.prototype.enterOpt_materialized = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_materialized. +PostgreSQLParserListener.prototype.exitOpt_materialized = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_with_clause. +PostgreSQLParserListener.prototype.enterOpt_with_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_with_clause. +PostgreSQLParserListener.prototype.exitOpt_with_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#into_clause. +PostgreSQLParserListener.prototype.enterInto_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#into_clause. +PostgreSQLParserListener.prototype.exitInto_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_strict. +PostgreSQLParserListener.prototype.enterOpt_strict = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_strict. +PostgreSQLParserListener.prototype.exitOpt_strict = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opttempTableName. +PostgreSQLParserListener.prototype.enterOpttempTableName = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opttempTableName. +PostgreSQLParserListener.prototype.exitOpttempTableName = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_table. +PostgreSQLParserListener.prototype.enterOpt_table = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_table. +PostgreSQLParserListener.prototype.exitOpt_table = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#all_or_distinct. +PostgreSQLParserListener.prototype.enterAll_or_distinct = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#all_or_distinct. +PostgreSQLParserListener.prototype.exitAll_or_distinct = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#distinct_clause. +PostgreSQLParserListener.prototype.enterDistinct_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#distinct_clause. +PostgreSQLParserListener.prototype.exitDistinct_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_all_clause. +PostgreSQLParserListener.prototype.enterOpt_all_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_all_clause. +PostgreSQLParserListener.prototype.exitOpt_all_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_sort_clause. +PostgreSQLParserListener.prototype.enterOpt_sort_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_sort_clause. +PostgreSQLParserListener.prototype.exitOpt_sort_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#sort_clause. +PostgreSQLParserListener.prototype.enterSort_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#sort_clause. +PostgreSQLParserListener.prototype.exitSort_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#sortby_list. +PostgreSQLParserListener.prototype.enterSortby_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#sortby_list. +PostgreSQLParserListener.prototype.exitSortby_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#sortby. +PostgreSQLParserListener.prototype.enterSortby = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#sortby. +PostgreSQLParserListener.prototype.exitSortby = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#select_limit. +PostgreSQLParserListener.prototype.enterSelect_limit = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#select_limit. +PostgreSQLParserListener.prototype.exitSelect_limit = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_select_limit. +PostgreSQLParserListener.prototype.enterOpt_select_limit = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_select_limit. +PostgreSQLParserListener.prototype.exitOpt_select_limit = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#limit_clause. +PostgreSQLParserListener.prototype.enterLimit_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#limit_clause. +PostgreSQLParserListener.prototype.exitLimit_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#offset_clause. +PostgreSQLParserListener.prototype.enterOffset_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#offset_clause. +PostgreSQLParserListener.prototype.exitOffset_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#select_limit_value. +PostgreSQLParserListener.prototype.enterSelect_limit_value = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#select_limit_value. +PostgreSQLParserListener.prototype.exitSelect_limit_value = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#select_offset_value. +PostgreSQLParserListener.prototype.enterSelect_offset_value = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#select_offset_value. +PostgreSQLParserListener.prototype.exitSelect_offset_value = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#select_fetch_first_value. +PostgreSQLParserListener.prototype.enterSelect_fetch_first_value = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#select_fetch_first_value. +PostgreSQLParserListener.prototype.exitSelect_fetch_first_value = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#i_or_f_const. +PostgreSQLParserListener.prototype.enterI_or_f_const = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#i_or_f_const. +PostgreSQLParserListener.prototype.exitI_or_f_const = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#row_or_rows. +PostgreSQLParserListener.prototype.enterRow_or_rows = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#row_or_rows. +PostgreSQLParserListener.prototype.exitRow_or_rows = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#first_or_next. +PostgreSQLParserListener.prototype.enterFirst_or_next = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#first_or_next. +PostgreSQLParserListener.prototype.exitFirst_or_next = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#group_clause. +PostgreSQLParserListener.prototype.enterGroup_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#group_clause. +PostgreSQLParserListener.prototype.exitGroup_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#group_by_list. +PostgreSQLParserListener.prototype.enterGroup_by_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#group_by_list. +PostgreSQLParserListener.prototype.exitGroup_by_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#group_by_item. +PostgreSQLParserListener.prototype.enterGroup_by_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#group_by_item. +PostgreSQLParserListener.prototype.exitGroup_by_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#empty_grouping_set. +PostgreSQLParserListener.prototype.enterEmpty_grouping_set = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#empty_grouping_set. +PostgreSQLParserListener.prototype.exitEmpty_grouping_set = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rollup_clause. +PostgreSQLParserListener.prototype.enterRollup_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rollup_clause. +PostgreSQLParserListener.prototype.exitRollup_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#cube_clause. +PostgreSQLParserListener.prototype.enterCube_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#cube_clause. +PostgreSQLParserListener.prototype.exitCube_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#grouping_sets_clause. +PostgreSQLParserListener.prototype.enterGrouping_sets_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#grouping_sets_clause. +PostgreSQLParserListener.prototype.exitGrouping_sets_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#having_clause. +PostgreSQLParserListener.prototype.enterHaving_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#having_clause. +PostgreSQLParserListener.prototype.exitHaving_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#for_locking_clause. +PostgreSQLParserListener.prototype.enterFor_locking_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#for_locking_clause. +PostgreSQLParserListener.prototype.exitFor_locking_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_for_locking_clause. +PostgreSQLParserListener.prototype.enterOpt_for_locking_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_for_locking_clause. +PostgreSQLParserListener.prototype.exitOpt_for_locking_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#for_locking_items. +PostgreSQLParserListener.prototype.enterFor_locking_items = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#for_locking_items. +PostgreSQLParserListener.prototype.exitFor_locking_items = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#for_locking_item. +PostgreSQLParserListener.prototype.enterFor_locking_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#for_locking_item. +PostgreSQLParserListener.prototype.exitFor_locking_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#for_locking_strength. +PostgreSQLParserListener.prototype.enterFor_locking_strength = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#for_locking_strength. +PostgreSQLParserListener.prototype.exitFor_locking_strength = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#locked_rels_list. +PostgreSQLParserListener.prototype.enterLocked_rels_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#locked_rels_list. +PostgreSQLParserListener.prototype.exitLocked_rels_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#values_clause. +PostgreSQLParserListener.prototype.enterValues_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#values_clause. +PostgreSQLParserListener.prototype.exitValues_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#from_clause. +PostgreSQLParserListener.prototype.enterFrom_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#from_clause. +PostgreSQLParserListener.prototype.exitFrom_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#from_list. +PostgreSQLParserListener.prototype.enterFrom_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#from_list. +PostgreSQLParserListener.prototype.exitFrom_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#table_ref. +PostgreSQLParserListener.prototype.enterTable_ref = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#table_ref. +PostgreSQLParserListener.prototype.exitTable_ref = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#alias_clause. +PostgreSQLParserListener.prototype.enterAlias_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#alias_clause. +PostgreSQLParserListener.prototype.exitAlias_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_alias_clause. +PostgreSQLParserListener.prototype.enterOpt_alias_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_alias_clause. +PostgreSQLParserListener.prototype.exitOpt_alias_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_alias_clause. +PostgreSQLParserListener.prototype.enterFunc_alias_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_alias_clause. +PostgreSQLParserListener.prototype.exitFunc_alias_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#join_type. +PostgreSQLParserListener.prototype.enterJoin_type = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#join_type. +PostgreSQLParserListener.prototype.exitJoin_type = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#join_qual. +PostgreSQLParserListener.prototype.enterJoin_qual = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#join_qual. +PostgreSQLParserListener.prototype.exitJoin_qual = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#relation_expr. +PostgreSQLParserListener.prototype.enterRelation_expr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#relation_expr. +PostgreSQLParserListener.prototype.exitRelation_expr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#relation_expr_list. +PostgreSQLParserListener.prototype.enterRelation_expr_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#relation_expr_list. +PostgreSQLParserListener.prototype.exitRelation_expr_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#relation_expr_opt_alias. +PostgreSQLParserListener.prototype.enterRelation_expr_opt_alias = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#relation_expr_opt_alias. +PostgreSQLParserListener.prototype.exitRelation_expr_opt_alias = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#tablesample_clause. +PostgreSQLParserListener.prototype.enterTablesample_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#tablesample_clause. +PostgreSQLParserListener.prototype.exitTablesample_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_repeatable_clause. +PostgreSQLParserListener.prototype.enterOpt_repeatable_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_repeatable_clause. +PostgreSQLParserListener.prototype.exitOpt_repeatable_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_table. +PostgreSQLParserListener.prototype.enterFunc_table = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_table. +PostgreSQLParserListener.prototype.exitFunc_table = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rowsfrom_item. +PostgreSQLParserListener.prototype.enterRowsfrom_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rowsfrom_item. +PostgreSQLParserListener.prototype.exitRowsfrom_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rowsfrom_list. +PostgreSQLParserListener.prototype.enterRowsfrom_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rowsfrom_list. +PostgreSQLParserListener.prototype.exitRowsfrom_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_col_def_list. +PostgreSQLParserListener.prototype.enterOpt_col_def_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_col_def_list. +PostgreSQLParserListener.prototype.exitOpt_col_def_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_ordinality. +PostgreSQLParserListener.prototype.enterOpt_ordinality = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_ordinality. +PostgreSQLParserListener.prototype.exitOpt_ordinality = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#where_clause. +PostgreSQLParserListener.prototype.enterWhere_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#where_clause. +PostgreSQLParserListener.prototype.exitWhere_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#where_or_current_clause. +PostgreSQLParserListener.prototype.enterWhere_or_current_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#where_or_current_clause. +PostgreSQLParserListener.prototype.exitWhere_or_current_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opttablefuncelementlist. +PostgreSQLParserListener.prototype.enterOpttablefuncelementlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opttablefuncelementlist. +PostgreSQLParserListener.prototype.exitOpttablefuncelementlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#tablefuncelementlist. +PostgreSQLParserListener.prototype.enterTablefuncelementlist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#tablefuncelementlist. +PostgreSQLParserListener.prototype.exitTablefuncelementlist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#tablefuncelement. +PostgreSQLParserListener.prototype.enterTablefuncelement = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#tablefuncelement. +PostgreSQLParserListener.prototype.exitTablefuncelement = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xmltable. +PostgreSQLParserListener.prototype.enterXmltable = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xmltable. +PostgreSQLParserListener.prototype.exitXmltable = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xmltable_column_list. +PostgreSQLParserListener.prototype.enterXmltable_column_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xmltable_column_list. +PostgreSQLParserListener.prototype.exitXmltable_column_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xmltable_column_el. +PostgreSQLParserListener.prototype.enterXmltable_column_el = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xmltable_column_el. +PostgreSQLParserListener.prototype.exitXmltable_column_el = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xmltable_column_option_list. +PostgreSQLParserListener.prototype.enterXmltable_column_option_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xmltable_column_option_list. +PostgreSQLParserListener.prototype.exitXmltable_column_option_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xmltable_column_option_el. +PostgreSQLParserListener.prototype.enterXmltable_column_option_el = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xmltable_column_option_el. +PostgreSQLParserListener.prototype.exitXmltable_column_option_el = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xml_namespace_list. +PostgreSQLParserListener.prototype.enterXml_namespace_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xml_namespace_list. +PostgreSQLParserListener.prototype.exitXml_namespace_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xml_namespace_el. +PostgreSQLParserListener.prototype.enterXml_namespace_el = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xml_namespace_el. +PostgreSQLParserListener.prototype.exitXml_namespace_el = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#typename. +PostgreSQLParserListener.prototype.enterTypename = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#typename. +PostgreSQLParserListener.prototype.exitTypename = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_array_bounds. +PostgreSQLParserListener.prototype.enterOpt_array_bounds = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_array_bounds. +PostgreSQLParserListener.prototype.exitOpt_array_bounds = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#simpletypename. +PostgreSQLParserListener.prototype.enterSimpletypename = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#simpletypename. +PostgreSQLParserListener.prototype.exitSimpletypename = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#consttypename. +PostgreSQLParserListener.prototype.enterConsttypename = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#consttypename. +PostgreSQLParserListener.prototype.exitConsttypename = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#generictype. +PostgreSQLParserListener.prototype.enterGenerictype = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#generictype. +PostgreSQLParserListener.prototype.exitGenerictype = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_type_modifiers. +PostgreSQLParserListener.prototype.enterOpt_type_modifiers = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_type_modifiers. +PostgreSQLParserListener.prototype.exitOpt_type_modifiers = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#numeric. +PostgreSQLParserListener.prototype.enterNumeric = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#numeric. +PostgreSQLParserListener.prototype.exitNumeric = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_float. +PostgreSQLParserListener.prototype.enterOpt_float = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_float. +PostgreSQLParserListener.prototype.exitOpt_float = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#bit. +PostgreSQLParserListener.prototype.enterBit = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#bit. +PostgreSQLParserListener.prototype.exitBit = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constbit. +PostgreSQLParserListener.prototype.enterConstbit = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constbit. +PostgreSQLParserListener.prototype.exitConstbit = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#bitwithlength. +PostgreSQLParserListener.prototype.enterBitwithlength = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#bitwithlength. +PostgreSQLParserListener.prototype.exitBitwithlength = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#bitwithoutlength. +PostgreSQLParserListener.prototype.enterBitwithoutlength = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#bitwithoutlength. +PostgreSQLParserListener.prototype.exitBitwithoutlength = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#character. +PostgreSQLParserListener.prototype.enterCharacter = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#character. +PostgreSQLParserListener.prototype.exitCharacter = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constcharacter. +PostgreSQLParserListener.prototype.enterConstcharacter = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constcharacter. +PostgreSQLParserListener.prototype.exitConstcharacter = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#character_c. +PostgreSQLParserListener.prototype.enterCharacter_c = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#character_c. +PostgreSQLParserListener.prototype.exitCharacter_c = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_varying. +PostgreSQLParserListener.prototype.enterOpt_varying = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_varying. +PostgreSQLParserListener.prototype.exitOpt_varying = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constdatetime. +PostgreSQLParserListener.prototype.enterConstdatetime = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constdatetime. +PostgreSQLParserListener.prototype.exitConstdatetime = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#constinterval. +PostgreSQLParserListener.prototype.enterConstinterval = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#constinterval. +PostgreSQLParserListener.prototype.exitConstinterval = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_timezone. +PostgreSQLParserListener.prototype.enterOpt_timezone = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_timezone. +PostgreSQLParserListener.prototype.exitOpt_timezone = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_interval. +PostgreSQLParserListener.prototype.enterOpt_interval = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_interval. +PostgreSQLParserListener.prototype.exitOpt_interval = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#interval_second. +PostgreSQLParserListener.prototype.enterInterval_second = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#interval_second. +PostgreSQLParserListener.prototype.exitInterval_second = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_escape. +PostgreSQLParserListener.prototype.enterOpt_escape = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_escape. +PostgreSQLParserListener.prototype.exitOpt_escape = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr. +PostgreSQLParserListener.prototype.enterA_expr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr. +PostgreSQLParserListener.prototype.exitA_expr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_qual. +PostgreSQLParserListener.prototype.enterA_expr_qual = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_qual. +PostgreSQLParserListener.prototype.exitA_expr_qual = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_lessless. +PostgreSQLParserListener.prototype.enterA_expr_lessless = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_lessless. +PostgreSQLParserListener.prototype.exitA_expr_lessless = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_or. +PostgreSQLParserListener.prototype.enterA_expr_or = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_or. +PostgreSQLParserListener.prototype.exitA_expr_or = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_and. +PostgreSQLParserListener.prototype.enterA_expr_and = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_and. +PostgreSQLParserListener.prototype.exitA_expr_and = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_in. +PostgreSQLParserListener.prototype.enterA_expr_in = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_in. +PostgreSQLParserListener.prototype.exitA_expr_in = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_unary_not. +PostgreSQLParserListener.prototype.enterA_expr_unary_not = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_unary_not. +PostgreSQLParserListener.prototype.exitA_expr_unary_not = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_isnull. +PostgreSQLParserListener.prototype.enterA_expr_isnull = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_isnull. +PostgreSQLParserListener.prototype.exitA_expr_isnull = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_is_not. +PostgreSQLParserListener.prototype.enterA_expr_is_not = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_is_not. +PostgreSQLParserListener.prototype.exitA_expr_is_not = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_compare. +PostgreSQLParserListener.prototype.enterA_expr_compare = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_compare. +PostgreSQLParserListener.prototype.exitA_expr_compare = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_like. +PostgreSQLParserListener.prototype.enterA_expr_like = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_like. +PostgreSQLParserListener.prototype.exitA_expr_like = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_qual_op. +PostgreSQLParserListener.prototype.enterA_expr_qual_op = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_qual_op. +PostgreSQLParserListener.prototype.exitA_expr_qual_op = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_unary_qualop. +PostgreSQLParserListener.prototype.enterA_expr_unary_qualop = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_unary_qualop. +PostgreSQLParserListener.prototype.exitA_expr_unary_qualop = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_add. +PostgreSQLParserListener.prototype.enterA_expr_add = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_add. +PostgreSQLParserListener.prototype.exitA_expr_add = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_mul. +PostgreSQLParserListener.prototype.enterA_expr_mul = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_mul. +PostgreSQLParserListener.prototype.exitA_expr_mul = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_caret. +PostgreSQLParserListener.prototype.enterA_expr_caret = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_caret. +PostgreSQLParserListener.prototype.exitA_expr_caret = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_unary_sign. +PostgreSQLParserListener.prototype.enterA_expr_unary_sign = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_unary_sign. +PostgreSQLParserListener.prototype.exitA_expr_unary_sign = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_at_time_zone. +PostgreSQLParserListener.prototype.enterA_expr_at_time_zone = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_at_time_zone. +PostgreSQLParserListener.prototype.exitA_expr_at_time_zone = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_collate. +PostgreSQLParserListener.prototype.enterA_expr_collate = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_collate. +PostgreSQLParserListener.prototype.exitA_expr_collate = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#a_expr_typecast. +PostgreSQLParserListener.prototype.enterA_expr_typecast = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#a_expr_typecast. +PostgreSQLParserListener.prototype.exitA_expr_typecast = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#b_expr. +PostgreSQLParserListener.prototype.enterB_expr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#b_expr. +PostgreSQLParserListener.prototype.exitB_expr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#c_expr_exists. +PostgreSQLParserListener.prototype.enterC_expr_exists = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#c_expr_exists. +PostgreSQLParserListener.prototype.exitC_expr_exists = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#c_expr_expr. +PostgreSQLParserListener.prototype.enterC_expr_expr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#c_expr_expr. +PostgreSQLParserListener.prototype.exitC_expr_expr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#c_expr_case. +PostgreSQLParserListener.prototype.enterC_expr_case = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#c_expr_case. +PostgreSQLParserListener.prototype.exitC_expr_case = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#plsqlvariablename. +PostgreSQLParserListener.prototype.enterPlsqlvariablename = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#plsqlvariablename. +PostgreSQLParserListener.prototype.exitPlsqlvariablename = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_application. +PostgreSQLParserListener.prototype.enterFunc_application = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_application. +PostgreSQLParserListener.prototype.exitFunc_application = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_expr. +PostgreSQLParserListener.prototype.enterFunc_expr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_expr. +PostgreSQLParserListener.prototype.exitFunc_expr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_expr_windowless. +PostgreSQLParserListener.prototype.enterFunc_expr_windowless = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_expr_windowless. +PostgreSQLParserListener.prototype.exitFunc_expr_windowless = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_expr_common_subexpr. +PostgreSQLParserListener.prototype.enterFunc_expr_common_subexpr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_expr_common_subexpr. +PostgreSQLParserListener.prototype.exitFunc_expr_common_subexpr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xml_root_version. +PostgreSQLParserListener.prototype.enterXml_root_version = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xml_root_version. +PostgreSQLParserListener.prototype.exitXml_root_version = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_xml_root_standalone. +PostgreSQLParserListener.prototype.enterOpt_xml_root_standalone = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_xml_root_standalone. +PostgreSQLParserListener.prototype.exitOpt_xml_root_standalone = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xml_attributes. +PostgreSQLParserListener.prototype.enterXml_attributes = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xml_attributes. +PostgreSQLParserListener.prototype.exitXml_attributes = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xml_attribute_list. +PostgreSQLParserListener.prototype.enterXml_attribute_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xml_attribute_list. +PostgreSQLParserListener.prototype.exitXml_attribute_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xml_attribute_el. +PostgreSQLParserListener.prototype.enterXml_attribute_el = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xml_attribute_el. +PostgreSQLParserListener.prototype.exitXml_attribute_el = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#document_or_content. +PostgreSQLParserListener.prototype.enterDocument_or_content = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#document_or_content. +PostgreSQLParserListener.prototype.exitDocument_or_content = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xml_whitespace_option. +PostgreSQLParserListener.prototype.enterXml_whitespace_option = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xml_whitespace_option. +PostgreSQLParserListener.prototype.exitXml_whitespace_option = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xmlexists_argument. +PostgreSQLParserListener.prototype.enterXmlexists_argument = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xmlexists_argument. +PostgreSQLParserListener.prototype.exitXmlexists_argument = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xml_passing_mech. +PostgreSQLParserListener.prototype.enterXml_passing_mech = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xml_passing_mech. +PostgreSQLParserListener.prototype.exitXml_passing_mech = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#within_group_clause. +PostgreSQLParserListener.prototype.enterWithin_group_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#within_group_clause. +PostgreSQLParserListener.prototype.exitWithin_group_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#filter_clause. +PostgreSQLParserListener.prototype.enterFilter_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#filter_clause. +PostgreSQLParserListener.prototype.exitFilter_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#window_clause. +PostgreSQLParserListener.prototype.enterWindow_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#window_clause. +PostgreSQLParserListener.prototype.exitWindow_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#window_definition_list. +PostgreSQLParserListener.prototype.enterWindow_definition_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#window_definition_list. +PostgreSQLParserListener.prototype.exitWindow_definition_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#window_definition. +PostgreSQLParserListener.prototype.enterWindow_definition = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#window_definition. +PostgreSQLParserListener.prototype.exitWindow_definition = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#over_clause. +PostgreSQLParserListener.prototype.enterOver_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#over_clause. +PostgreSQLParserListener.prototype.exitOver_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#window_specification. +PostgreSQLParserListener.prototype.enterWindow_specification = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#window_specification. +PostgreSQLParserListener.prototype.exitWindow_specification = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_existing_window_name. +PostgreSQLParserListener.prototype.enterOpt_existing_window_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_existing_window_name. +PostgreSQLParserListener.prototype.exitOpt_existing_window_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_partition_clause. +PostgreSQLParserListener.prototype.enterOpt_partition_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_partition_clause. +PostgreSQLParserListener.prototype.exitOpt_partition_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_frame_clause. +PostgreSQLParserListener.prototype.enterOpt_frame_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_frame_clause. +PostgreSQLParserListener.prototype.exitOpt_frame_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#frame_extent. +PostgreSQLParserListener.prototype.enterFrame_extent = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#frame_extent. +PostgreSQLParserListener.prototype.exitFrame_extent = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#frame_bound. +PostgreSQLParserListener.prototype.enterFrame_bound = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#frame_bound. +PostgreSQLParserListener.prototype.exitFrame_bound = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_window_exclusion_clause. +PostgreSQLParserListener.prototype.enterOpt_window_exclusion_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_window_exclusion_clause. +PostgreSQLParserListener.prototype.exitOpt_window_exclusion_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#row. +PostgreSQLParserListener.prototype.enterRow = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#row. +PostgreSQLParserListener.prototype.exitRow = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#explicit_row. +PostgreSQLParserListener.prototype.enterExplicit_row = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#explicit_row. +PostgreSQLParserListener.prototype.exitExplicit_row = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#implicit_row. +PostgreSQLParserListener.prototype.enterImplicit_row = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#implicit_row. +PostgreSQLParserListener.prototype.exitImplicit_row = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#sub_type. +PostgreSQLParserListener.prototype.enterSub_type = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#sub_type. +PostgreSQLParserListener.prototype.exitSub_type = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#all_op. +PostgreSQLParserListener.prototype.enterAll_op = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#all_op. +PostgreSQLParserListener.prototype.exitAll_op = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#mathop. +PostgreSQLParserListener.prototype.enterMathop = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#mathop. +PostgreSQLParserListener.prototype.exitMathop = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#qual_op. +PostgreSQLParserListener.prototype.enterQual_op = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#qual_op. +PostgreSQLParserListener.prototype.exitQual_op = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#qual_all_op. +PostgreSQLParserListener.prototype.enterQual_all_op = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#qual_all_op. +PostgreSQLParserListener.prototype.exitQual_all_op = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#subquery_Op. +PostgreSQLParserListener.prototype.enterSubquery_Op = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#subquery_Op. +PostgreSQLParserListener.prototype.exitSubquery_Op = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#expr_list. +PostgreSQLParserListener.prototype.enterExpr_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#expr_list. +PostgreSQLParserListener.prototype.exitExpr_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_arg_list. +PostgreSQLParserListener.prototype.enterFunc_arg_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_arg_list. +PostgreSQLParserListener.prototype.exitFunc_arg_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_arg_expr. +PostgreSQLParserListener.prototype.enterFunc_arg_expr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_arg_expr. +PostgreSQLParserListener.prototype.exitFunc_arg_expr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#type_list. +PostgreSQLParserListener.prototype.enterType_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#type_list. +PostgreSQLParserListener.prototype.exitType_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#array_expr. +PostgreSQLParserListener.prototype.enterArray_expr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#array_expr. +PostgreSQLParserListener.prototype.exitArray_expr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#array_expr_list. +PostgreSQLParserListener.prototype.enterArray_expr_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#array_expr_list. +PostgreSQLParserListener.prototype.exitArray_expr_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#extract_list. +PostgreSQLParserListener.prototype.enterExtract_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#extract_list. +PostgreSQLParserListener.prototype.exitExtract_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#extract_arg. +PostgreSQLParserListener.prototype.enterExtract_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#extract_arg. +PostgreSQLParserListener.prototype.exitExtract_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#unicode_normal_form. +PostgreSQLParserListener.prototype.enterUnicode_normal_form = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#unicode_normal_form. +PostgreSQLParserListener.prototype.exitUnicode_normal_form = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#overlay_list. +PostgreSQLParserListener.prototype.enterOverlay_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#overlay_list. +PostgreSQLParserListener.prototype.exitOverlay_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#position_list. +PostgreSQLParserListener.prototype.enterPosition_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#position_list. +PostgreSQLParserListener.prototype.exitPosition_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#substr_list. +PostgreSQLParserListener.prototype.enterSubstr_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#substr_list. +PostgreSQLParserListener.prototype.exitSubstr_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#trim_list. +PostgreSQLParserListener.prototype.enterTrim_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#trim_list. +PostgreSQLParserListener.prototype.exitTrim_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#in_expr_select. +PostgreSQLParserListener.prototype.enterIn_expr_select = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#in_expr_select. +PostgreSQLParserListener.prototype.exitIn_expr_select = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#in_expr_list. +PostgreSQLParserListener.prototype.enterIn_expr_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#in_expr_list. +PostgreSQLParserListener.prototype.exitIn_expr_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#case_expr. +PostgreSQLParserListener.prototype.enterCase_expr = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#case_expr. +PostgreSQLParserListener.prototype.exitCase_expr = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#when_clause_list. +PostgreSQLParserListener.prototype.enterWhen_clause_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#when_clause_list. +PostgreSQLParserListener.prototype.exitWhen_clause_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#when_clause. +PostgreSQLParserListener.prototype.enterWhen_clause = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#when_clause. +PostgreSQLParserListener.prototype.exitWhen_clause = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#case_default. +PostgreSQLParserListener.prototype.enterCase_default = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#case_default. +PostgreSQLParserListener.prototype.exitCase_default = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#case_arg. +PostgreSQLParserListener.prototype.enterCase_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#case_arg. +PostgreSQLParserListener.prototype.exitCase_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#columnref. +PostgreSQLParserListener.prototype.enterColumnref = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#columnref. +PostgreSQLParserListener.prototype.exitColumnref = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#indirection_el. +PostgreSQLParserListener.prototype.enterIndirection_el = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#indirection_el. +PostgreSQLParserListener.prototype.exitIndirection_el = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_slice_bound. +PostgreSQLParserListener.prototype.enterOpt_slice_bound = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_slice_bound. +PostgreSQLParserListener.prototype.exitOpt_slice_bound = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#indirection. +PostgreSQLParserListener.prototype.enterIndirection = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#indirection. +PostgreSQLParserListener.prototype.exitIndirection = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_indirection. +PostgreSQLParserListener.prototype.enterOpt_indirection = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_indirection. +PostgreSQLParserListener.prototype.exitOpt_indirection = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_target_list. +PostgreSQLParserListener.prototype.enterOpt_target_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_target_list. +PostgreSQLParserListener.prototype.exitOpt_target_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#target_list. +PostgreSQLParserListener.prototype.enterTarget_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#target_list. +PostgreSQLParserListener.prototype.exitTarget_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#target_label. +PostgreSQLParserListener.prototype.enterTarget_label = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#target_label. +PostgreSQLParserListener.prototype.exitTarget_label = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#target_star. +PostgreSQLParserListener.prototype.enterTarget_star = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#target_star. +PostgreSQLParserListener.prototype.exitTarget_star = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#qualified_name_list. +PostgreSQLParserListener.prototype.enterQualified_name_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#qualified_name_list. +PostgreSQLParserListener.prototype.exitQualified_name_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#qualified_name. +PostgreSQLParserListener.prototype.enterQualified_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#qualified_name. +PostgreSQLParserListener.prototype.exitQualified_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#name_list. +PostgreSQLParserListener.prototype.enterName_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#name_list. +PostgreSQLParserListener.prototype.exitName_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#name. +PostgreSQLParserListener.prototype.enterName = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#name. +PostgreSQLParserListener.prototype.exitName = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#attr_name. +PostgreSQLParserListener.prototype.enterAttr_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#attr_name. +PostgreSQLParserListener.prototype.exitAttr_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#file_name. +PostgreSQLParserListener.prototype.enterFile_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#file_name. +PostgreSQLParserListener.prototype.exitFile_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#func_name. +PostgreSQLParserListener.prototype.enterFunc_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#func_name. +PostgreSQLParserListener.prototype.exitFunc_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#aexprconst. +PostgreSQLParserListener.prototype.enterAexprconst = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#aexprconst. +PostgreSQLParserListener.prototype.exitAexprconst = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#xconst. +PostgreSQLParserListener.prototype.enterXconst = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#xconst. +PostgreSQLParserListener.prototype.exitXconst = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#bconst. +PostgreSQLParserListener.prototype.enterBconst = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#bconst. +PostgreSQLParserListener.prototype.exitBconst = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#fconst. +PostgreSQLParserListener.prototype.enterFconst = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#fconst. +PostgreSQLParserListener.prototype.exitFconst = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#iconst. +PostgreSQLParserListener.prototype.enterIconst = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#iconst. +PostgreSQLParserListener.prototype.exitIconst = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#sconst. +PostgreSQLParserListener.prototype.enterSconst = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#sconst. +PostgreSQLParserListener.prototype.exitSconst = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#anysconst. +PostgreSQLParserListener.prototype.enterAnysconst = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#anysconst. +PostgreSQLParserListener.prototype.exitAnysconst = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_uescape. +PostgreSQLParserListener.prototype.enterOpt_uescape = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_uescape. +PostgreSQLParserListener.prototype.exitOpt_uescape = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#signediconst. +PostgreSQLParserListener.prototype.enterSignediconst = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#signediconst. +PostgreSQLParserListener.prototype.exitSignediconst = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#roleid. +PostgreSQLParserListener.prototype.enterRoleid = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#roleid. +PostgreSQLParserListener.prototype.exitRoleid = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#rolespec. +PostgreSQLParserListener.prototype.enterRolespec = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#rolespec. +PostgreSQLParserListener.prototype.exitRolespec = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#role_list. +PostgreSQLParserListener.prototype.enterRole_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#role_list. +PostgreSQLParserListener.prototype.exitRole_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#colid. +PostgreSQLParserListener.prototype.enterColid = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#colid. +PostgreSQLParserListener.prototype.exitColid = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#type_function_name. +PostgreSQLParserListener.prototype.enterType_function_name = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#type_function_name. +PostgreSQLParserListener.prototype.exitType_function_name = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#nonreservedword. +PostgreSQLParserListener.prototype.enterNonreservedword = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#nonreservedword. +PostgreSQLParserListener.prototype.exitNonreservedword = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#collabel. +PostgreSQLParserListener.prototype.enterCollabel = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#collabel. +PostgreSQLParserListener.prototype.exitCollabel = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#identifier. +PostgreSQLParserListener.prototype.enterIdentifier = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#identifier. +PostgreSQLParserListener.prototype.exitIdentifier = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#plsqlidentifier. +PostgreSQLParserListener.prototype.enterPlsqlidentifier = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#plsqlidentifier. +PostgreSQLParserListener.prototype.exitPlsqlidentifier = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#unreserved_keyword. +PostgreSQLParserListener.prototype.enterUnreserved_keyword = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#unreserved_keyword. +PostgreSQLParserListener.prototype.exitUnreserved_keyword = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#col_name_keyword. +PostgreSQLParserListener.prototype.enterCol_name_keyword = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#col_name_keyword. +PostgreSQLParserListener.prototype.exitCol_name_keyword = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#type_func_name_keyword. +PostgreSQLParserListener.prototype.enterType_func_name_keyword = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#type_func_name_keyword. +PostgreSQLParserListener.prototype.exitType_func_name_keyword = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#reserved_keyword. +PostgreSQLParserListener.prototype.enterReserved_keyword = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#reserved_keyword. +PostgreSQLParserListener.prototype.exitReserved_keyword = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#pl_function. +PostgreSQLParserListener.prototype.enterPl_function = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#pl_function. +PostgreSQLParserListener.prototype.exitPl_function = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#comp_options. +PostgreSQLParserListener.prototype.enterComp_options = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#comp_options. +PostgreSQLParserListener.prototype.exitComp_options = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#comp_option. +PostgreSQLParserListener.prototype.enterComp_option = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#comp_option. +PostgreSQLParserListener.prototype.exitComp_option = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#sharp. +PostgreSQLParserListener.prototype.enterSharp = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#sharp. +PostgreSQLParserListener.prototype.exitSharp = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#option_value. +PostgreSQLParserListener.prototype.enterOption_value = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#option_value. +PostgreSQLParserListener.prototype.exitOption_value = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_semi. +PostgreSQLParserListener.prototype.enterOpt_semi = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_semi. +PostgreSQLParserListener.prototype.exitOpt_semi = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#pl_block. +PostgreSQLParserListener.prototype.enterPl_block = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#pl_block. +PostgreSQLParserListener.prototype.exitPl_block = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_sect. +PostgreSQLParserListener.prototype.enterDecl_sect = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_sect. +PostgreSQLParserListener.prototype.exitDecl_sect = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_start. +PostgreSQLParserListener.prototype.enterDecl_start = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_start. +PostgreSQLParserListener.prototype.exitDecl_start = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_stmts. +PostgreSQLParserListener.prototype.enterDecl_stmts = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_stmts. +PostgreSQLParserListener.prototype.exitDecl_stmts = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#label_decl. +PostgreSQLParserListener.prototype.enterLabel_decl = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#label_decl. +PostgreSQLParserListener.prototype.exitLabel_decl = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_stmt. +PostgreSQLParserListener.prototype.enterDecl_stmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_stmt. +PostgreSQLParserListener.prototype.exitDecl_stmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_statement. +PostgreSQLParserListener.prototype.enterDecl_statement = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_statement. +PostgreSQLParserListener.prototype.exitDecl_statement = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_scrollable. +PostgreSQLParserListener.prototype.enterOpt_scrollable = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_scrollable. +PostgreSQLParserListener.prototype.exitOpt_scrollable = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_cursor_query. +PostgreSQLParserListener.prototype.enterDecl_cursor_query = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_cursor_query. +PostgreSQLParserListener.prototype.exitDecl_cursor_query = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_cursor_args. +PostgreSQLParserListener.prototype.enterDecl_cursor_args = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_cursor_args. +PostgreSQLParserListener.prototype.exitDecl_cursor_args = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_cursor_arglist. +PostgreSQLParserListener.prototype.enterDecl_cursor_arglist = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_cursor_arglist. +PostgreSQLParserListener.prototype.exitDecl_cursor_arglist = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_cursor_arg. +PostgreSQLParserListener.prototype.enterDecl_cursor_arg = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_cursor_arg. +PostgreSQLParserListener.prototype.exitDecl_cursor_arg = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_is_for. +PostgreSQLParserListener.prototype.enterDecl_is_for = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_is_for. +PostgreSQLParserListener.prototype.exitDecl_is_for = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_aliasitem. +PostgreSQLParserListener.prototype.enterDecl_aliasitem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_aliasitem. +PostgreSQLParserListener.prototype.exitDecl_aliasitem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_varname. +PostgreSQLParserListener.prototype.enterDecl_varname = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_varname. +PostgreSQLParserListener.prototype.exitDecl_varname = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_const. +PostgreSQLParserListener.prototype.enterDecl_const = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_const. +PostgreSQLParserListener.prototype.exitDecl_const = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_datatype. +PostgreSQLParserListener.prototype.enterDecl_datatype = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_datatype. +PostgreSQLParserListener.prototype.exitDecl_datatype = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_collate. +PostgreSQLParserListener.prototype.enterDecl_collate = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_collate. +PostgreSQLParserListener.prototype.exitDecl_collate = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_notnull. +PostgreSQLParserListener.prototype.enterDecl_notnull = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_notnull. +PostgreSQLParserListener.prototype.exitDecl_notnull = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_defval. +PostgreSQLParserListener.prototype.enterDecl_defval = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_defval. +PostgreSQLParserListener.prototype.exitDecl_defval = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#decl_defkey. +PostgreSQLParserListener.prototype.enterDecl_defkey = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#decl_defkey. +PostgreSQLParserListener.prototype.exitDecl_defkey = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#assign_operator. +PostgreSQLParserListener.prototype.enterAssign_operator = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#assign_operator. +PostgreSQLParserListener.prototype.exitAssign_operator = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#proc_sect. +PostgreSQLParserListener.prototype.enterProc_sect = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#proc_sect. +PostgreSQLParserListener.prototype.exitProc_sect = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#proc_stmt. +PostgreSQLParserListener.prototype.enterProc_stmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#proc_stmt. +PostgreSQLParserListener.prototype.exitProc_stmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_perform. +PostgreSQLParserListener.prototype.enterStmt_perform = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_perform. +PostgreSQLParserListener.prototype.exitStmt_perform = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_call. +PostgreSQLParserListener.prototype.enterStmt_call = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_call. +PostgreSQLParserListener.prototype.exitStmt_call = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_expr_list. +PostgreSQLParserListener.prototype.enterOpt_expr_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_expr_list. +PostgreSQLParserListener.prototype.exitOpt_expr_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_assign. +PostgreSQLParserListener.prototype.enterStmt_assign = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_assign. +PostgreSQLParserListener.prototype.exitStmt_assign = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_getdiag. +PostgreSQLParserListener.prototype.enterStmt_getdiag = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_getdiag. +PostgreSQLParserListener.prototype.exitStmt_getdiag = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#getdiag_area_opt. +PostgreSQLParserListener.prototype.enterGetdiag_area_opt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#getdiag_area_opt. +PostgreSQLParserListener.prototype.exitGetdiag_area_opt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#getdiag_list. +PostgreSQLParserListener.prototype.enterGetdiag_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#getdiag_list. +PostgreSQLParserListener.prototype.exitGetdiag_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#getdiag_list_item. +PostgreSQLParserListener.prototype.enterGetdiag_list_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#getdiag_list_item. +PostgreSQLParserListener.prototype.exitGetdiag_list_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#getdiag_item. +PostgreSQLParserListener.prototype.enterGetdiag_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#getdiag_item. +PostgreSQLParserListener.prototype.exitGetdiag_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#getdiag_target. +PostgreSQLParserListener.prototype.enterGetdiag_target = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#getdiag_target. +PostgreSQLParserListener.prototype.exitGetdiag_target = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#assign_var. +PostgreSQLParserListener.prototype.enterAssign_var = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#assign_var. +PostgreSQLParserListener.prototype.exitAssign_var = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_if. +PostgreSQLParserListener.prototype.enterStmt_if = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_if. +PostgreSQLParserListener.prototype.exitStmt_if = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_elsifs. +PostgreSQLParserListener.prototype.enterStmt_elsifs = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_elsifs. +PostgreSQLParserListener.prototype.exitStmt_elsifs = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_else. +PostgreSQLParserListener.prototype.enterStmt_else = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_else. +PostgreSQLParserListener.prototype.exitStmt_else = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_case. +PostgreSQLParserListener.prototype.enterStmt_case = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_case. +PostgreSQLParserListener.prototype.exitStmt_case = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_expr_until_when. +PostgreSQLParserListener.prototype.enterOpt_expr_until_when = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_expr_until_when. +PostgreSQLParserListener.prototype.exitOpt_expr_until_when = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#case_when_list. +PostgreSQLParserListener.prototype.enterCase_when_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#case_when_list. +PostgreSQLParserListener.prototype.exitCase_when_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#case_when. +PostgreSQLParserListener.prototype.enterCase_when = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#case_when. +PostgreSQLParserListener.prototype.exitCase_when = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_case_else. +PostgreSQLParserListener.prototype.enterOpt_case_else = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_case_else. +PostgreSQLParserListener.prototype.exitOpt_case_else = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_loop. +PostgreSQLParserListener.prototype.enterStmt_loop = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_loop. +PostgreSQLParserListener.prototype.exitStmt_loop = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_while. +PostgreSQLParserListener.prototype.enterStmt_while = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_while. +PostgreSQLParserListener.prototype.exitStmt_while = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_for. +PostgreSQLParserListener.prototype.enterStmt_for = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_for. +PostgreSQLParserListener.prototype.exitStmt_for = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#for_control. +PostgreSQLParserListener.prototype.enterFor_control = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#for_control. +PostgreSQLParserListener.prototype.exitFor_control = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_for_using_expression. +PostgreSQLParserListener.prototype.enterOpt_for_using_expression = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_for_using_expression. +PostgreSQLParserListener.prototype.exitOpt_for_using_expression = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_cursor_parameters. +PostgreSQLParserListener.prototype.enterOpt_cursor_parameters = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_cursor_parameters. +PostgreSQLParserListener.prototype.exitOpt_cursor_parameters = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_reverse. +PostgreSQLParserListener.prototype.enterOpt_reverse = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_reverse. +PostgreSQLParserListener.prototype.exitOpt_reverse = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_by_expression. +PostgreSQLParserListener.prototype.enterOpt_by_expression = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_by_expression. +PostgreSQLParserListener.prototype.exitOpt_by_expression = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#for_variable. +PostgreSQLParserListener.prototype.enterFor_variable = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#for_variable. +PostgreSQLParserListener.prototype.exitFor_variable = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_foreach_a. +PostgreSQLParserListener.prototype.enterStmt_foreach_a = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_foreach_a. +PostgreSQLParserListener.prototype.exitStmt_foreach_a = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#foreach_slice. +PostgreSQLParserListener.prototype.enterForeach_slice = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#foreach_slice. +PostgreSQLParserListener.prototype.exitForeach_slice = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_exit. +PostgreSQLParserListener.prototype.enterStmt_exit = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_exit. +PostgreSQLParserListener.prototype.exitStmt_exit = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#exit_type. +PostgreSQLParserListener.prototype.enterExit_type = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#exit_type. +PostgreSQLParserListener.prototype.exitExit_type = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_return. +PostgreSQLParserListener.prototype.enterStmt_return = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_return. +PostgreSQLParserListener.prototype.exitStmt_return = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_return_result. +PostgreSQLParserListener.prototype.enterOpt_return_result = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_return_result. +PostgreSQLParserListener.prototype.exitOpt_return_result = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_raise. +PostgreSQLParserListener.prototype.enterStmt_raise = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_raise. +PostgreSQLParserListener.prototype.exitStmt_raise = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_stmt_raise_level. +PostgreSQLParserListener.prototype.enterOpt_stmt_raise_level = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_stmt_raise_level. +PostgreSQLParserListener.prototype.exitOpt_stmt_raise_level = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_raise_list. +PostgreSQLParserListener.prototype.enterOpt_raise_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_raise_list. +PostgreSQLParserListener.prototype.exitOpt_raise_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_raise_using. +PostgreSQLParserListener.prototype.enterOpt_raise_using = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_raise_using. +PostgreSQLParserListener.prototype.exitOpt_raise_using = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_raise_using_elem. +PostgreSQLParserListener.prototype.enterOpt_raise_using_elem = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_raise_using_elem. +PostgreSQLParserListener.prototype.exitOpt_raise_using_elem = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_raise_using_elem_list. +PostgreSQLParserListener.prototype.enterOpt_raise_using_elem_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_raise_using_elem_list. +PostgreSQLParserListener.prototype.exitOpt_raise_using_elem_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_assert. +PostgreSQLParserListener.prototype.enterStmt_assert = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_assert. +PostgreSQLParserListener.prototype.exitStmt_assert = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_stmt_assert_message. +PostgreSQLParserListener.prototype.enterOpt_stmt_assert_message = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_stmt_assert_message. +PostgreSQLParserListener.prototype.exitOpt_stmt_assert_message = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#loop_body. +PostgreSQLParserListener.prototype.enterLoop_body = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#loop_body. +PostgreSQLParserListener.prototype.exitLoop_body = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_execsql. +PostgreSQLParserListener.prototype.enterStmt_execsql = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_execsql. +PostgreSQLParserListener.prototype.exitStmt_execsql = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_dynexecute. +PostgreSQLParserListener.prototype.enterStmt_dynexecute = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_dynexecute. +PostgreSQLParserListener.prototype.exitStmt_dynexecute = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_execute_using. +PostgreSQLParserListener.prototype.enterOpt_execute_using = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_execute_using. +PostgreSQLParserListener.prototype.exitOpt_execute_using = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_execute_using_list. +PostgreSQLParserListener.prototype.enterOpt_execute_using_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_execute_using_list. +PostgreSQLParserListener.prototype.exitOpt_execute_using_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_execute_into. +PostgreSQLParserListener.prototype.enterOpt_execute_into = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_execute_into. +PostgreSQLParserListener.prototype.exitOpt_execute_into = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_open. +PostgreSQLParserListener.prototype.enterStmt_open = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_open. +PostgreSQLParserListener.prototype.exitStmt_open = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_open_bound_list_item. +PostgreSQLParserListener.prototype.enterOpt_open_bound_list_item = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_open_bound_list_item. +PostgreSQLParserListener.prototype.exitOpt_open_bound_list_item = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_open_bound_list. +PostgreSQLParserListener.prototype.enterOpt_open_bound_list = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_open_bound_list. +PostgreSQLParserListener.prototype.exitOpt_open_bound_list = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_open_using. +PostgreSQLParserListener.prototype.enterOpt_open_using = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_open_using. +PostgreSQLParserListener.prototype.exitOpt_open_using = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_scroll_option. +PostgreSQLParserListener.prototype.enterOpt_scroll_option = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_scroll_option. +PostgreSQLParserListener.prototype.exitOpt_scroll_option = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_scroll_option_no. +PostgreSQLParserListener.prototype.enterOpt_scroll_option_no = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_scroll_option_no. +PostgreSQLParserListener.prototype.exitOpt_scroll_option_no = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_fetch. +PostgreSQLParserListener.prototype.enterStmt_fetch = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_fetch. +PostgreSQLParserListener.prototype.exitStmt_fetch = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#into_target. +PostgreSQLParserListener.prototype.enterInto_target = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#into_target. +PostgreSQLParserListener.prototype.exitInto_target = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_cursor_from. +PostgreSQLParserListener.prototype.enterOpt_cursor_from = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_cursor_from. +PostgreSQLParserListener.prototype.exitOpt_cursor_from = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_fetch_direction. +PostgreSQLParserListener.prototype.enterOpt_fetch_direction = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_fetch_direction. +PostgreSQLParserListener.prototype.exitOpt_fetch_direction = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_move. +PostgreSQLParserListener.prototype.enterStmt_move = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_move. +PostgreSQLParserListener.prototype.exitStmt_move = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_close. +PostgreSQLParserListener.prototype.enterStmt_close = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_close. +PostgreSQLParserListener.prototype.exitStmt_close = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_null. +PostgreSQLParserListener.prototype.enterStmt_null = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_null. +PostgreSQLParserListener.prototype.exitStmt_null = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_commit. +PostgreSQLParserListener.prototype.enterStmt_commit = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_commit. +PostgreSQLParserListener.prototype.exitStmt_commit = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_rollback. +PostgreSQLParserListener.prototype.enterStmt_rollback = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_rollback. +PostgreSQLParserListener.prototype.exitStmt_rollback = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#plsql_opt_transaction_chain. +PostgreSQLParserListener.prototype.enterPlsql_opt_transaction_chain = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#plsql_opt_transaction_chain. +PostgreSQLParserListener.prototype.exitPlsql_opt_transaction_chain = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#stmt_set. +PostgreSQLParserListener.prototype.enterStmt_set = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#stmt_set. +PostgreSQLParserListener.prototype.exitStmt_set = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#cursor_variable. +PostgreSQLParserListener.prototype.enterCursor_variable = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#cursor_variable. +PostgreSQLParserListener.prototype.exitCursor_variable = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#exception_sect. +PostgreSQLParserListener.prototype.enterException_sect = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#exception_sect. +PostgreSQLParserListener.prototype.exitException_sect = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#proc_exceptions. +PostgreSQLParserListener.prototype.enterProc_exceptions = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#proc_exceptions. +PostgreSQLParserListener.prototype.exitProc_exceptions = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#proc_exception. +PostgreSQLParserListener.prototype.enterProc_exception = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#proc_exception. +PostgreSQLParserListener.prototype.exitProc_exception = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#proc_conditions. +PostgreSQLParserListener.prototype.enterProc_conditions = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#proc_conditions. +PostgreSQLParserListener.prototype.exitProc_conditions = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#proc_condition. +PostgreSQLParserListener.prototype.enterProc_condition = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#proc_condition. +PostgreSQLParserListener.prototype.exitProc_condition = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_block_label. +PostgreSQLParserListener.prototype.enterOpt_block_label = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_block_label. +PostgreSQLParserListener.prototype.exitOpt_block_label = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_loop_label. +PostgreSQLParserListener.prototype.enterOpt_loop_label = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_loop_label. +PostgreSQLParserListener.prototype.exitOpt_loop_label = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_label. +PostgreSQLParserListener.prototype.enterOpt_label = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_label. +PostgreSQLParserListener.prototype.exitOpt_label = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_exitcond. +PostgreSQLParserListener.prototype.enterOpt_exitcond = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_exitcond. +PostgreSQLParserListener.prototype.exitOpt_exitcond = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#any_identifier. +PostgreSQLParserListener.prototype.enterAny_identifier = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#any_identifier. +PostgreSQLParserListener.prototype.exitAny_identifier = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#plsql_unreserved_keyword. +PostgreSQLParserListener.prototype.enterPlsql_unreserved_keyword = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#plsql_unreserved_keyword. +PostgreSQLParserListener.prototype.exitPlsql_unreserved_keyword = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#sql_expression. +PostgreSQLParserListener.prototype.enterSql_expression = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#sql_expression. +PostgreSQLParserListener.prototype.exitSql_expression = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#expr_until_then. +PostgreSQLParserListener.prototype.enterExpr_until_then = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#expr_until_then. +PostgreSQLParserListener.prototype.exitExpr_until_then = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#expr_until_semi. +PostgreSQLParserListener.prototype.enterExpr_until_semi = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#expr_until_semi. +PostgreSQLParserListener.prototype.exitExpr_until_semi = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#expr_until_rightbracket. +PostgreSQLParserListener.prototype.enterExpr_until_rightbracket = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#expr_until_rightbracket. +PostgreSQLParserListener.prototype.exitExpr_until_rightbracket = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#expr_until_loop. +PostgreSQLParserListener.prototype.enterExpr_until_loop = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#expr_until_loop. +PostgreSQLParserListener.prototype.exitExpr_until_loop = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#make_execsql_stmt. +PostgreSQLParserListener.prototype.enterMake_execsql_stmt = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#make_execsql_stmt. +PostgreSQLParserListener.prototype.exitMake_execsql_stmt = function(ctx) { +}; + + +// Enter a parse tree produced by PostgreSQLParser#opt_returning_clause_into. +PostgreSQLParserListener.prototype.enterOpt_returning_clause_into = function(ctx) { +}; + +// Exit a parse tree produced by PostgreSQLParser#opt_returning_clause_into. +PostgreSQLParserListener.prototype.exitOpt_returning_clause_into = function(ctx) { +}; + + + +exports.PostgreSQLParserListener = PostgreSQLParserListener; \ No newline at end of file diff --git a/src/lib/pgsql/PostgreSQLParserVisitor.js b/src/lib/pgsql/PostgreSQLParserVisitor.js new file mode 100644 index 0000000..760777e --- /dev/null +++ b/src/lib/pgsql/PostgreSQLParserVisitor.js @@ -0,0 +1,4876 @@ +// Generated from /Users/salvo/dt-sql-parser2/src/grammar/pgsql/PostgreSQLParser.g4 by ANTLR 4.8 +// jshint ignore: start +var antlr4 = require('antlr4/index'); + +// This class defines a complete generic visitor for a parse tree produced by PostgreSQLParser. + +function PostgreSQLParserVisitor() { + antlr4.tree.ParseTreeVisitor.call(this); + return this; +} + +PostgreSQLParserVisitor.prototype = Object.create(antlr4.tree.ParseTreeVisitor.prototype); +PostgreSQLParserVisitor.prototype.constructor = PostgreSQLParserVisitor; + +// Visit a parse tree produced by PostgreSQLParser#root. +PostgreSQLParserVisitor.prototype.visitRoot = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#plsqlroot. +PostgreSQLParserVisitor.prototype.visitPlsqlroot = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmtblock. +PostgreSQLParserVisitor.prototype.visitStmtblock = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmtmulti. +PostgreSQLParserVisitor.prototype.visitStmtmulti = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt. +PostgreSQLParserVisitor.prototype.visitStmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#plsqlconsolecommand. +PostgreSQLParserVisitor.prototype.visitPlsqlconsolecommand = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#callstmt. +PostgreSQLParserVisitor.prototype.visitCallstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createrolestmt. +PostgreSQLParserVisitor.prototype.visitCreaterolestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_with. +PostgreSQLParserVisitor.prototype.visitOpt_with = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optrolelist. +PostgreSQLParserVisitor.prototype.visitOptrolelist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alteroptrolelist. +PostgreSQLParserVisitor.prototype.visitAlteroptrolelist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alteroptroleelem. +PostgreSQLParserVisitor.prototype.visitAlteroptroleelem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createoptroleelem. +PostgreSQLParserVisitor.prototype.visitCreateoptroleelem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createuserstmt. +PostgreSQLParserVisitor.prototype.visitCreateuserstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterrolestmt. +PostgreSQLParserVisitor.prototype.visitAlterrolestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_in_database. +PostgreSQLParserVisitor.prototype.visitOpt_in_database = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterrolesetstmt. +PostgreSQLParserVisitor.prototype.visitAlterrolesetstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#droprolestmt. +PostgreSQLParserVisitor.prototype.visitDroprolestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#creategroupstmt. +PostgreSQLParserVisitor.prototype.visitCreategroupstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altergroupstmt. +PostgreSQLParserVisitor.prototype.visitAltergroupstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#add_drop. +PostgreSQLParserVisitor.prototype.visitAdd_drop = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createschemastmt. +PostgreSQLParserVisitor.prototype.visitCreateschemastmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optschemaname. +PostgreSQLParserVisitor.prototype.visitOptschemaname = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optschemaeltlist. +PostgreSQLParserVisitor.prototype.visitOptschemaeltlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#schema_stmt. +PostgreSQLParserVisitor.prototype.visitSchema_stmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#variablesetstmt. +PostgreSQLParserVisitor.prototype.visitVariablesetstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#set_rest. +PostgreSQLParserVisitor.prototype.visitSet_rest = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#generic_set. +PostgreSQLParserVisitor.prototype.visitGeneric_set = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#set_rest_more. +PostgreSQLParserVisitor.prototype.visitSet_rest_more = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#var_name. +PostgreSQLParserVisitor.prototype.visitVar_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#var_list. +PostgreSQLParserVisitor.prototype.visitVar_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#var_value. +PostgreSQLParserVisitor.prototype.visitVar_value = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#iso_level. +PostgreSQLParserVisitor.prototype.visitIso_level = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_boolean_or_string. +PostgreSQLParserVisitor.prototype.visitOpt_boolean_or_string = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#zone_value. +PostgreSQLParserVisitor.prototype.visitZone_value = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_encoding. +PostgreSQLParserVisitor.prototype.visitOpt_encoding = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#nonreservedword_or_sconst. +PostgreSQLParserVisitor.prototype.visitNonreservedword_or_sconst = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#variableresetstmt. +PostgreSQLParserVisitor.prototype.visitVariableresetstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reset_rest. +PostgreSQLParserVisitor.prototype.visitReset_rest = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#generic_reset. +PostgreSQLParserVisitor.prototype.visitGeneric_reset = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#setresetclause. +PostgreSQLParserVisitor.prototype.visitSetresetclause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#functionsetresetclause. +PostgreSQLParserVisitor.prototype.visitFunctionsetresetclause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#variableshowstmt. +PostgreSQLParserVisitor.prototype.visitVariableshowstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constraintssetstmt. +PostgreSQLParserVisitor.prototype.visitConstraintssetstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constraints_set_list. +PostgreSQLParserVisitor.prototype.visitConstraints_set_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constraints_set_mode. +PostgreSQLParserVisitor.prototype.visitConstraints_set_mode = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#checkpointstmt. +PostgreSQLParserVisitor.prototype.visitCheckpointstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#discardstmt. +PostgreSQLParserVisitor.prototype.visitDiscardstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altertablestmt. +PostgreSQLParserVisitor.prototype.visitAltertablestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_table_cmds. +PostgreSQLParserVisitor.prototype.visitAlter_table_cmds = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#partition_cmd. +PostgreSQLParserVisitor.prototype.visitPartition_cmd = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#index_partition_cmd. +PostgreSQLParserVisitor.prototype.visitIndex_partition_cmd = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_table_cmd. +PostgreSQLParserVisitor.prototype.visitAlter_table_cmd = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_column_default. +PostgreSQLParserVisitor.prototype.visitAlter_column_default = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_drop_behavior. +PostgreSQLParserVisitor.prototype.visitOpt_drop_behavior = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_collate_clause. +PostgreSQLParserVisitor.prototype.visitOpt_collate_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_using. +PostgreSQLParserVisitor.prototype.visitAlter_using = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#replica_identity. +PostgreSQLParserVisitor.prototype.visitReplica_identity = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reloptions. +PostgreSQLParserVisitor.prototype.visitReloptions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_reloptions. +PostgreSQLParserVisitor.prototype.visitOpt_reloptions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reloption_list. +PostgreSQLParserVisitor.prototype.visitReloption_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reloption_elem. +PostgreSQLParserVisitor.prototype.visitReloption_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_identity_column_option_list. +PostgreSQLParserVisitor.prototype.visitAlter_identity_column_option_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_identity_column_option. +PostgreSQLParserVisitor.prototype.visitAlter_identity_column_option = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#partitionboundspec. +PostgreSQLParserVisitor.prototype.visitPartitionboundspec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#hash_partbound_elem. +PostgreSQLParserVisitor.prototype.visitHash_partbound_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#hash_partbound. +PostgreSQLParserVisitor.prototype.visitHash_partbound = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altercompositetypestmt. +PostgreSQLParserVisitor.prototype.visitAltercompositetypestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_type_cmds. +PostgreSQLParserVisitor.prototype.visitAlter_type_cmds = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_type_cmd. +PostgreSQLParserVisitor.prototype.visitAlter_type_cmd = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#closeportalstmt. +PostgreSQLParserVisitor.prototype.visitCloseportalstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copystmt. +PostgreSQLParserVisitor.prototype.visitCopystmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_from. +PostgreSQLParserVisitor.prototype.visitCopy_from = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_program. +PostgreSQLParserVisitor.prototype.visitOpt_program = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_file_name. +PostgreSQLParserVisitor.prototype.visitCopy_file_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_options. +PostgreSQLParserVisitor.prototype.visitCopy_options = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_opt_list. +PostgreSQLParserVisitor.prototype.visitCopy_opt_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_opt_item. +PostgreSQLParserVisitor.prototype.visitCopy_opt_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_binary. +PostgreSQLParserVisitor.prototype.visitOpt_binary = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_delimiter. +PostgreSQLParserVisitor.prototype.visitCopy_delimiter = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_using. +PostgreSQLParserVisitor.prototype.visitOpt_using = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_generic_opt_list. +PostgreSQLParserVisitor.prototype.visitCopy_generic_opt_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_generic_opt_elem. +PostgreSQLParserVisitor.prototype.visitCopy_generic_opt_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_generic_opt_arg. +PostgreSQLParserVisitor.prototype.visitCopy_generic_opt_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_generic_opt_arg_list. +PostgreSQLParserVisitor.prototype.visitCopy_generic_opt_arg_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#copy_generic_opt_arg_list_item. +PostgreSQLParserVisitor.prototype.visitCopy_generic_opt_arg_list_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createstmt. +PostgreSQLParserVisitor.prototype.visitCreatestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opttemp. +PostgreSQLParserVisitor.prototype.visitOpttemp = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opttableelementlist. +PostgreSQLParserVisitor.prototype.visitOpttableelementlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opttypedtableelementlist. +PostgreSQLParserVisitor.prototype.visitOpttypedtableelementlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#tableelementlist. +PostgreSQLParserVisitor.prototype.visitTableelementlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#typedtableelementlist. +PostgreSQLParserVisitor.prototype.visitTypedtableelementlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#tableelement. +PostgreSQLParserVisitor.prototype.visitTableelement = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#typedtableelement. +PostgreSQLParserVisitor.prototype.visitTypedtableelement = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#columnDef. +PostgreSQLParserVisitor.prototype.visitColumnDef = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#columnOptions. +PostgreSQLParserVisitor.prototype.visitColumnOptions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#colquallist. +PostgreSQLParserVisitor.prototype.visitColquallist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#colconstraint. +PostgreSQLParserVisitor.prototype.visitColconstraint = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#colconstraintelem. +PostgreSQLParserVisitor.prototype.visitColconstraintelem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#generated_when. +PostgreSQLParserVisitor.prototype.visitGenerated_when = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constraintattr. +PostgreSQLParserVisitor.prototype.visitConstraintattr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#tablelikeclause. +PostgreSQLParserVisitor.prototype.visitTablelikeclause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#tablelikeoptionlist. +PostgreSQLParserVisitor.prototype.visitTablelikeoptionlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#tablelikeoption. +PostgreSQLParserVisitor.prototype.visitTablelikeoption = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#tableconstraint. +PostgreSQLParserVisitor.prototype.visitTableconstraint = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constraintelem. +PostgreSQLParserVisitor.prototype.visitConstraintelem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_no_inherit. +PostgreSQLParserVisitor.prototype.visitOpt_no_inherit = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_column_list. +PostgreSQLParserVisitor.prototype.visitOpt_column_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#columnlist. +PostgreSQLParserVisitor.prototype.visitColumnlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#columnElem. +PostgreSQLParserVisitor.prototype.visitColumnElem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_c_include. +PostgreSQLParserVisitor.prototype.visitOpt_c_include = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#key_match. +PostgreSQLParserVisitor.prototype.visitKey_match = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#exclusionconstraintlist. +PostgreSQLParserVisitor.prototype.visitExclusionconstraintlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#exclusionconstraintelem. +PostgreSQLParserVisitor.prototype.visitExclusionconstraintelem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#exclusionwhereclause. +PostgreSQLParserVisitor.prototype.visitExclusionwhereclause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#key_actions. +PostgreSQLParserVisitor.prototype.visitKey_actions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#key_update. +PostgreSQLParserVisitor.prototype.visitKey_update = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#key_delete. +PostgreSQLParserVisitor.prototype.visitKey_delete = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#key_action. +PostgreSQLParserVisitor.prototype.visitKey_action = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optinherit. +PostgreSQLParserVisitor.prototype.visitOptinherit = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optpartitionspec. +PostgreSQLParserVisitor.prototype.visitOptpartitionspec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#partitionspec. +PostgreSQLParserVisitor.prototype.visitPartitionspec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#part_params. +PostgreSQLParserVisitor.prototype.visitPart_params = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#part_elem. +PostgreSQLParserVisitor.prototype.visitPart_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#table_access_method_clause. +PostgreSQLParserVisitor.prototype.visitTable_access_method_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optwith. +PostgreSQLParserVisitor.prototype.visitOptwith = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#oncommitoption. +PostgreSQLParserVisitor.prototype.visitOncommitoption = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opttablespace. +PostgreSQLParserVisitor.prototype.visitOpttablespace = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optconstablespace. +PostgreSQLParserVisitor.prototype.visitOptconstablespace = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#existingindex. +PostgreSQLParserVisitor.prototype.visitExistingindex = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createstatsstmt. +PostgreSQLParserVisitor.prototype.visitCreatestatsstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterstatsstmt. +PostgreSQLParserVisitor.prototype.visitAlterstatsstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createasstmt. +PostgreSQLParserVisitor.prototype.visitCreateasstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#create_as_target. +PostgreSQLParserVisitor.prototype.visitCreate_as_target = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_with_data. +PostgreSQLParserVisitor.prototype.visitOpt_with_data = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#creatematviewstmt. +PostgreSQLParserVisitor.prototype.visitCreatematviewstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#create_mv_target. +PostgreSQLParserVisitor.prototype.visitCreate_mv_target = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optnolog. +PostgreSQLParserVisitor.prototype.visitOptnolog = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#refreshmatviewstmt. +PostgreSQLParserVisitor.prototype.visitRefreshmatviewstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createseqstmt. +PostgreSQLParserVisitor.prototype.visitCreateseqstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterseqstmt. +PostgreSQLParserVisitor.prototype.visitAlterseqstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optseqoptlist. +PostgreSQLParserVisitor.prototype.visitOptseqoptlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optparenthesizedseqoptlist. +PostgreSQLParserVisitor.prototype.visitOptparenthesizedseqoptlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#seqoptlist. +PostgreSQLParserVisitor.prototype.visitSeqoptlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#seqoptelem. +PostgreSQLParserVisitor.prototype.visitSeqoptelem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_by. +PostgreSQLParserVisitor.prototype.visitOpt_by = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#numericonly. +PostgreSQLParserVisitor.prototype.visitNumericonly = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#numericonly_list. +PostgreSQLParserVisitor.prototype.visitNumericonly_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createplangstmt. +PostgreSQLParserVisitor.prototype.visitCreateplangstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_trusted. +PostgreSQLParserVisitor.prototype.visitOpt_trusted = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#handler_name. +PostgreSQLParserVisitor.prototype.visitHandler_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_inline_handler. +PostgreSQLParserVisitor.prototype.visitOpt_inline_handler = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#validator_clause. +PostgreSQLParserVisitor.prototype.visitValidator_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_validator. +PostgreSQLParserVisitor.prototype.visitOpt_validator = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_procedural. +PostgreSQLParserVisitor.prototype.visitOpt_procedural = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createtablespacestmt. +PostgreSQLParserVisitor.prototype.visitCreatetablespacestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opttablespaceowner. +PostgreSQLParserVisitor.prototype.visitOpttablespaceowner = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#droptablespacestmt. +PostgreSQLParserVisitor.prototype.visitDroptablespacestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createextensionstmt. +PostgreSQLParserVisitor.prototype.visitCreateextensionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#create_extension_opt_list. +PostgreSQLParserVisitor.prototype.visitCreate_extension_opt_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#create_extension_opt_item. +PostgreSQLParserVisitor.prototype.visitCreate_extension_opt_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterextensionstmt. +PostgreSQLParserVisitor.prototype.visitAlterextensionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_extension_opt_list. +PostgreSQLParserVisitor.prototype.visitAlter_extension_opt_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_extension_opt_item. +PostgreSQLParserVisitor.prototype.visitAlter_extension_opt_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterextensioncontentsstmt. +PostgreSQLParserVisitor.prototype.visitAlterextensioncontentsstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createfdwstmt. +PostgreSQLParserVisitor.prototype.visitCreatefdwstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#fdw_option. +PostgreSQLParserVisitor.prototype.visitFdw_option = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#fdw_options. +PostgreSQLParserVisitor.prototype.visitFdw_options = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_fdw_options. +PostgreSQLParserVisitor.prototype.visitOpt_fdw_options = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterfdwstmt. +PostgreSQLParserVisitor.prototype.visitAlterfdwstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#create_generic_options. +PostgreSQLParserVisitor.prototype.visitCreate_generic_options = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#generic_option_list. +PostgreSQLParserVisitor.prototype.visitGeneric_option_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_generic_options. +PostgreSQLParserVisitor.prototype.visitAlter_generic_options = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_generic_option_list. +PostgreSQLParserVisitor.prototype.visitAlter_generic_option_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alter_generic_option_elem. +PostgreSQLParserVisitor.prototype.visitAlter_generic_option_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#generic_option_elem. +PostgreSQLParserVisitor.prototype.visitGeneric_option_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#generic_option_name. +PostgreSQLParserVisitor.prototype.visitGeneric_option_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#generic_option_arg. +PostgreSQLParserVisitor.prototype.visitGeneric_option_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createforeignserverstmt. +PostgreSQLParserVisitor.prototype.visitCreateforeignserverstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_type. +PostgreSQLParserVisitor.prototype.visitOpt_type = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#foreign_server_version. +PostgreSQLParserVisitor.prototype.visitForeign_server_version = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_foreign_server_version. +PostgreSQLParserVisitor.prototype.visitOpt_foreign_server_version = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterforeignserverstmt. +PostgreSQLParserVisitor.prototype.visitAlterforeignserverstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createforeigntablestmt. +PostgreSQLParserVisitor.prototype.visitCreateforeigntablestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#importforeignschemastmt. +PostgreSQLParserVisitor.prototype.visitImportforeignschemastmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#import_qualification_type. +PostgreSQLParserVisitor.prototype.visitImport_qualification_type = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#import_qualification. +PostgreSQLParserVisitor.prototype.visitImport_qualification = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createusermappingstmt. +PostgreSQLParserVisitor.prototype.visitCreateusermappingstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#auth_ident. +PostgreSQLParserVisitor.prototype.visitAuth_ident = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dropusermappingstmt. +PostgreSQLParserVisitor.prototype.visitDropusermappingstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterusermappingstmt. +PostgreSQLParserVisitor.prototype.visitAlterusermappingstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createpolicystmt. +PostgreSQLParserVisitor.prototype.visitCreatepolicystmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterpolicystmt. +PostgreSQLParserVisitor.prototype.visitAlterpolicystmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rowsecurityoptionalexpr. +PostgreSQLParserVisitor.prototype.visitRowsecurityoptionalexpr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rowsecurityoptionalwithcheck. +PostgreSQLParserVisitor.prototype.visitRowsecurityoptionalwithcheck = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rowsecuritydefaulttorole. +PostgreSQLParserVisitor.prototype.visitRowsecuritydefaulttorole = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rowsecurityoptionaltorole. +PostgreSQLParserVisitor.prototype.visitRowsecurityoptionaltorole = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rowsecuritydefaultpermissive. +PostgreSQLParserVisitor.prototype.visitRowsecuritydefaultpermissive = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rowsecuritydefaultforcmd. +PostgreSQLParserVisitor.prototype.visitRowsecuritydefaultforcmd = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#row_security_cmd. +PostgreSQLParserVisitor.prototype.visitRow_security_cmd = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createamstmt. +PostgreSQLParserVisitor.prototype.visitCreateamstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#am_type. +PostgreSQLParserVisitor.prototype.visitAm_type = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createtrigstmt. +PostgreSQLParserVisitor.prototype.visitCreatetrigstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggeractiontime. +PostgreSQLParserVisitor.prototype.visitTriggeractiontime = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggerevents. +PostgreSQLParserVisitor.prototype.visitTriggerevents = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggeroneevent. +PostgreSQLParserVisitor.prototype.visitTriggeroneevent = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggerreferencing. +PostgreSQLParserVisitor.prototype.visitTriggerreferencing = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggertransitions. +PostgreSQLParserVisitor.prototype.visitTriggertransitions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggertransition. +PostgreSQLParserVisitor.prototype.visitTriggertransition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#transitionoldornew. +PostgreSQLParserVisitor.prototype.visitTransitionoldornew = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#transitionrowortable. +PostgreSQLParserVisitor.prototype.visitTransitionrowortable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#transitionrelname. +PostgreSQLParserVisitor.prototype.visitTransitionrelname = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggerforspec. +PostgreSQLParserVisitor.prototype.visitTriggerforspec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggerforopteach. +PostgreSQLParserVisitor.prototype.visitTriggerforopteach = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggerfortype. +PostgreSQLParserVisitor.prototype.visitTriggerfortype = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggerwhen. +PostgreSQLParserVisitor.prototype.visitTriggerwhen = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#function_or_procedure. +PostgreSQLParserVisitor.prototype.visitFunction_or_procedure = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggerfuncargs. +PostgreSQLParserVisitor.prototype.visitTriggerfuncargs = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#triggerfuncarg. +PostgreSQLParserVisitor.prototype.visitTriggerfuncarg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#optconstrfromtable. +PostgreSQLParserVisitor.prototype.visitOptconstrfromtable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constraintattributespec. +PostgreSQLParserVisitor.prototype.visitConstraintattributespec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constraintattributeElem. +PostgreSQLParserVisitor.prototype.visitConstraintattributeElem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createeventtrigstmt. +PostgreSQLParserVisitor.prototype.visitCreateeventtrigstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#event_trigger_when_list. +PostgreSQLParserVisitor.prototype.visitEvent_trigger_when_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#event_trigger_when_item. +PostgreSQLParserVisitor.prototype.visitEvent_trigger_when_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#event_trigger_value_list. +PostgreSQLParserVisitor.prototype.visitEvent_trigger_value_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altereventtrigstmt. +PostgreSQLParserVisitor.prototype.visitAltereventtrigstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#enable_trigger. +PostgreSQLParserVisitor.prototype.visitEnable_trigger = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createassertionstmt. +PostgreSQLParserVisitor.prototype.visitCreateassertionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#definestmt. +PostgreSQLParserVisitor.prototype.visitDefinestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#definition. +PostgreSQLParserVisitor.prototype.visitDefinition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#def_list. +PostgreSQLParserVisitor.prototype.visitDef_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#def_elem. +PostgreSQLParserVisitor.prototype.visitDef_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#def_arg. +PostgreSQLParserVisitor.prototype.visitDef_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#old_aggr_definition. +PostgreSQLParserVisitor.prototype.visitOld_aggr_definition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#old_aggr_list. +PostgreSQLParserVisitor.prototype.visitOld_aggr_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#old_aggr_elem. +PostgreSQLParserVisitor.prototype.visitOld_aggr_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_enum_val_list. +PostgreSQLParserVisitor.prototype.visitOpt_enum_val_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#enum_val_list. +PostgreSQLParserVisitor.prototype.visitEnum_val_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterenumstmt. +PostgreSQLParserVisitor.prototype.visitAlterenumstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_if_not_exists. +PostgreSQLParserVisitor.prototype.visitOpt_if_not_exists = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createopclassstmt. +PostgreSQLParserVisitor.prototype.visitCreateopclassstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opclass_item_list. +PostgreSQLParserVisitor.prototype.visitOpclass_item_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opclass_item. +PostgreSQLParserVisitor.prototype.visitOpclass_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_default. +PostgreSQLParserVisitor.prototype.visitOpt_default = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_opfamily. +PostgreSQLParserVisitor.prototype.visitOpt_opfamily = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opclass_purpose. +PostgreSQLParserVisitor.prototype.visitOpclass_purpose = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_recheck. +PostgreSQLParserVisitor.prototype.visitOpt_recheck = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createopfamilystmt. +PostgreSQLParserVisitor.prototype.visitCreateopfamilystmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alteropfamilystmt. +PostgreSQLParserVisitor.prototype.visitAlteropfamilystmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opclass_drop_list. +PostgreSQLParserVisitor.prototype.visitOpclass_drop_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opclass_drop. +PostgreSQLParserVisitor.prototype.visitOpclass_drop = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dropopclassstmt. +PostgreSQLParserVisitor.prototype.visitDropopclassstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dropopfamilystmt. +PostgreSQLParserVisitor.prototype.visitDropopfamilystmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dropownedstmt. +PostgreSQLParserVisitor.prototype.visitDropownedstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reassignownedstmt. +PostgreSQLParserVisitor.prototype.visitReassignownedstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dropstmt. +PostgreSQLParserVisitor.prototype.visitDropstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#object_type_any_name. +PostgreSQLParserVisitor.prototype.visitObject_type_any_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#object_type_name. +PostgreSQLParserVisitor.prototype.visitObject_type_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#drop_type_name. +PostgreSQLParserVisitor.prototype.visitDrop_type_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#object_type_name_on_any_name. +PostgreSQLParserVisitor.prototype.visitObject_type_name_on_any_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#any_name_list. +PostgreSQLParserVisitor.prototype.visitAny_name_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#any_name. +PostgreSQLParserVisitor.prototype.visitAny_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#attrs. +PostgreSQLParserVisitor.prototype.visitAttrs = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#type_name_list. +PostgreSQLParserVisitor.prototype.visitType_name_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#truncatestmt. +PostgreSQLParserVisitor.prototype.visitTruncatestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_restart_seqs. +PostgreSQLParserVisitor.prototype.visitOpt_restart_seqs = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#commentstmt. +PostgreSQLParserVisitor.prototype.visitCommentstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#comment_text. +PostgreSQLParserVisitor.prototype.visitComment_text = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#seclabelstmt. +PostgreSQLParserVisitor.prototype.visitSeclabelstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_provider. +PostgreSQLParserVisitor.prototype.visitOpt_provider = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#security_label. +PostgreSQLParserVisitor.prototype.visitSecurity_label = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#fetchstmt. +PostgreSQLParserVisitor.prototype.visitFetchstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#fetch_args. +PostgreSQLParserVisitor.prototype.visitFetch_args = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#from_in. +PostgreSQLParserVisitor.prototype.visitFrom_in = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_from_in. +PostgreSQLParserVisitor.prototype.visitOpt_from_in = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#grantstmt. +PostgreSQLParserVisitor.prototype.visitGrantstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#revokestmt. +PostgreSQLParserVisitor.prototype.visitRevokestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#privileges. +PostgreSQLParserVisitor.prototype.visitPrivileges = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#privilege_list. +PostgreSQLParserVisitor.prototype.visitPrivilege_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#privilege. +PostgreSQLParserVisitor.prototype.visitPrivilege = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#privilege_target. +PostgreSQLParserVisitor.prototype.visitPrivilege_target = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#grantee_list. +PostgreSQLParserVisitor.prototype.visitGrantee_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#grantee. +PostgreSQLParserVisitor.prototype.visitGrantee = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_grant_grant_option. +PostgreSQLParserVisitor.prototype.visitOpt_grant_grant_option = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#grantrolestmt. +PostgreSQLParserVisitor.prototype.visitGrantrolestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#revokerolestmt. +PostgreSQLParserVisitor.prototype.visitRevokerolestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_grant_admin_option. +PostgreSQLParserVisitor.prototype.visitOpt_grant_admin_option = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_granted_by. +PostgreSQLParserVisitor.prototype.visitOpt_granted_by = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterdefaultprivilegesstmt. +PostgreSQLParserVisitor.prototype.visitAlterdefaultprivilegesstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#defacloptionlist. +PostgreSQLParserVisitor.prototype.visitDefacloptionlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#defacloption. +PostgreSQLParserVisitor.prototype.visitDefacloption = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#defaclaction. +PostgreSQLParserVisitor.prototype.visitDefaclaction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#defacl_privilege_target. +PostgreSQLParserVisitor.prototype.visitDefacl_privilege_target = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#indexstmt. +PostgreSQLParserVisitor.prototype.visitIndexstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_unique. +PostgreSQLParserVisitor.prototype.visitOpt_unique = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_concurrently. +PostgreSQLParserVisitor.prototype.visitOpt_concurrently = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_index_name. +PostgreSQLParserVisitor.prototype.visitOpt_index_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#access_method_clause. +PostgreSQLParserVisitor.prototype.visitAccess_method_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#index_params. +PostgreSQLParserVisitor.prototype.visitIndex_params = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#index_elem_options. +PostgreSQLParserVisitor.prototype.visitIndex_elem_options = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#index_elem. +PostgreSQLParserVisitor.prototype.visitIndex_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_include. +PostgreSQLParserVisitor.prototype.visitOpt_include = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#index_including_params. +PostgreSQLParserVisitor.prototype.visitIndex_including_params = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_collate. +PostgreSQLParserVisitor.prototype.visitOpt_collate = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_class. +PostgreSQLParserVisitor.prototype.visitOpt_class = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_asc_desc. +PostgreSQLParserVisitor.prototype.visitOpt_asc_desc = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_nulls_order. +PostgreSQLParserVisitor.prototype.visitOpt_nulls_order = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createfunctionstmt. +PostgreSQLParserVisitor.prototype.visitCreatefunctionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_or_replace. +PostgreSQLParserVisitor.prototype.visitOpt_or_replace = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_args. +PostgreSQLParserVisitor.prototype.visitFunc_args = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_args_list. +PostgreSQLParserVisitor.prototype.visitFunc_args_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#function_with_argtypes_list. +PostgreSQLParserVisitor.prototype.visitFunction_with_argtypes_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#function_with_argtypes. +PostgreSQLParserVisitor.prototype.visitFunction_with_argtypes = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_args_with_defaults. +PostgreSQLParserVisitor.prototype.visitFunc_args_with_defaults = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_args_with_defaults_list. +PostgreSQLParserVisitor.prototype.visitFunc_args_with_defaults_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_arg. +PostgreSQLParserVisitor.prototype.visitFunc_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#arg_class. +PostgreSQLParserVisitor.prototype.visitArg_class = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#param_name. +PostgreSQLParserVisitor.prototype.visitParam_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_return. +PostgreSQLParserVisitor.prototype.visitFunc_return = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_type. +PostgreSQLParserVisitor.prototype.visitFunc_type = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_arg_with_default. +PostgreSQLParserVisitor.prototype.visitFunc_arg_with_default = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#aggr_arg. +PostgreSQLParserVisitor.prototype.visitAggr_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#aggr_args. +PostgreSQLParserVisitor.prototype.visitAggr_args = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#aggr_args_list. +PostgreSQLParserVisitor.prototype.visitAggr_args_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#aggregate_with_argtypes. +PostgreSQLParserVisitor.prototype.visitAggregate_with_argtypes = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#aggregate_with_argtypes_list. +PostgreSQLParserVisitor.prototype.visitAggregate_with_argtypes_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createfunc_opt_list. +PostgreSQLParserVisitor.prototype.visitCreatefunc_opt_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#common_func_opt_item. +PostgreSQLParserVisitor.prototype.visitCommon_func_opt_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createfunc_opt_item. +PostgreSQLParserVisitor.prototype.visitCreatefunc_opt_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_as. +PostgreSQLParserVisitor.prototype.visitFunc_as = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#transform_type_list. +PostgreSQLParserVisitor.prototype.visitTransform_type_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_definition. +PostgreSQLParserVisitor.prototype.visitOpt_definition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#table_func_column. +PostgreSQLParserVisitor.prototype.visitTable_func_column = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#table_func_column_list. +PostgreSQLParserVisitor.prototype.visitTable_func_column_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterfunctionstmt. +PostgreSQLParserVisitor.prototype.visitAlterfunctionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterfunc_opt_list. +PostgreSQLParserVisitor.prototype.visitAlterfunc_opt_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_restrict. +PostgreSQLParserVisitor.prototype.visitOpt_restrict = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#removefuncstmt. +PostgreSQLParserVisitor.prototype.visitRemovefuncstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#removeaggrstmt. +PostgreSQLParserVisitor.prototype.visitRemoveaggrstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#removeoperstmt. +PostgreSQLParserVisitor.prototype.visitRemoveoperstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#oper_argtypes. +PostgreSQLParserVisitor.prototype.visitOper_argtypes = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#any_operator. +PostgreSQLParserVisitor.prototype.visitAny_operator = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#operator_with_argtypes_list. +PostgreSQLParserVisitor.prototype.visitOperator_with_argtypes_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#operator_with_argtypes. +PostgreSQLParserVisitor.prototype.visitOperator_with_argtypes = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dostmt. +PostgreSQLParserVisitor.prototype.visitDostmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dostmt_opt_list. +PostgreSQLParserVisitor.prototype.visitDostmt_opt_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dostmt_opt_item. +PostgreSQLParserVisitor.prototype.visitDostmt_opt_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createcaststmt. +PostgreSQLParserVisitor.prototype.visitCreatecaststmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#cast_context. +PostgreSQLParserVisitor.prototype.visitCast_context = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dropcaststmt. +PostgreSQLParserVisitor.prototype.visitDropcaststmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_if_exists. +PostgreSQLParserVisitor.prototype.visitOpt_if_exists = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createtransformstmt. +PostgreSQLParserVisitor.prototype.visitCreatetransformstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#transform_element_list. +PostgreSQLParserVisitor.prototype.visitTransform_element_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#droptransformstmt. +PostgreSQLParserVisitor.prototype.visitDroptransformstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reindexstmt. +PostgreSQLParserVisitor.prototype.visitReindexstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reindex_target_type. +PostgreSQLParserVisitor.prototype.visitReindex_target_type = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reindex_target_multitable. +PostgreSQLParserVisitor.prototype.visitReindex_target_multitable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reindex_option_list. +PostgreSQLParserVisitor.prototype.visitReindex_option_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reindex_option_elem. +PostgreSQLParserVisitor.prototype.visitReindex_option_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altertblspcstmt. +PostgreSQLParserVisitor.prototype.visitAltertblspcstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#renamestmt. +PostgreSQLParserVisitor.prototype.visitRenamestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_column. +PostgreSQLParserVisitor.prototype.visitOpt_column = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_set_data. +PostgreSQLParserVisitor.prototype.visitOpt_set_data = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterobjectdependsstmt. +PostgreSQLParserVisitor.prototype.visitAlterobjectdependsstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_no. +PostgreSQLParserVisitor.prototype.visitOpt_no = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterobjectschemastmt. +PostgreSQLParserVisitor.prototype.visitAlterobjectschemastmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alteroperatorstmt. +PostgreSQLParserVisitor.prototype.visitAlteroperatorstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#operator_def_list. +PostgreSQLParserVisitor.prototype.visitOperator_def_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#operator_def_elem. +PostgreSQLParserVisitor.prototype.visitOperator_def_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#operator_def_arg. +PostgreSQLParserVisitor.prototype.visitOperator_def_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altertypestmt. +PostgreSQLParserVisitor.prototype.visitAltertypestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterownerstmt. +PostgreSQLParserVisitor.prototype.visitAlterownerstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createpublicationstmt. +PostgreSQLParserVisitor.prototype.visitCreatepublicationstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_publication_for_tables. +PostgreSQLParserVisitor.prototype.visitOpt_publication_for_tables = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#publication_for_tables. +PostgreSQLParserVisitor.prototype.visitPublication_for_tables = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterpublicationstmt. +PostgreSQLParserVisitor.prototype.visitAlterpublicationstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createsubscriptionstmt. +PostgreSQLParserVisitor.prototype.visitCreatesubscriptionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#publication_name_list. +PostgreSQLParserVisitor.prototype.visitPublication_name_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#publication_name_item. +PostgreSQLParserVisitor.prototype.visitPublication_name_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altersubscriptionstmt. +PostgreSQLParserVisitor.prototype.visitAltersubscriptionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dropsubscriptionstmt. +PostgreSQLParserVisitor.prototype.visitDropsubscriptionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rulestmt. +PostgreSQLParserVisitor.prototype.visitRulestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#ruleactionlist. +PostgreSQLParserVisitor.prototype.visitRuleactionlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#ruleactionmulti. +PostgreSQLParserVisitor.prototype.visitRuleactionmulti = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#ruleactionstmt. +PostgreSQLParserVisitor.prototype.visitRuleactionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#ruleactionstmtOrEmpty. +PostgreSQLParserVisitor.prototype.visitRuleactionstmtOrEmpty = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#event. +PostgreSQLParserVisitor.prototype.visitEvent = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_instead. +PostgreSQLParserVisitor.prototype.visitOpt_instead = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#notifystmt. +PostgreSQLParserVisitor.prototype.visitNotifystmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#notify_payload. +PostgreSQLParserVisitor.prototype.visitNotify_payload = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#listenstmt. +PostgreSQLParserVisitor.prototype.visitListenstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#unlistenstmt. +PostgreSQLParserVisitor.prototype.visitUnlistenstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#transactionstmt. +PostgreSQLParserVisitor.prototype.visitTransactionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_transaction. +PostgreSQLParserVisitor.prototype.visitOpt_transaction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#transaction_mode_item. +PostgreSQLParserVisitor.prototype.visitTransaction_mode_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#transaction_mode_list. +PostgreSQLParserVisitor.prototype.visitTransaction_mode_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#transaction_mode_list_or_empty. +PostgreSQLParserVisitor.prototype.visitTransaction_mode_list_or_empty = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_transaction_chain. +PostgreSQLParserVisitor.prototype.visitOpt_transaction_chain = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#viewstmt. +PostgreSQLParserVisitor.prototype.visitViewstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_check_option. +PostgreSQLParserVisitor.prototype.visitOpt_check_option = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#loadstmt. +PostgreSQLParserVisitor.prototype.visitLoadstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createdbstmt. +PostgreSQLParserVisitor.prototype.visitCreatedbstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createdb_opt_list. +PostgreSQLParserVisitor.prototype.visitCreatedb_opt_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createdb_opt_items. +PostgreSQLParserVisitor.prototype.visitCreatedb_opt_items = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createdb_opt_item. +PostgreSQLParserVisitor.prototype.visitCreatedb_opt_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createdb_opt_name. +PostgreSQLParserVisitor.prototype.visitCreatedb_opt_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_equal. +PostgreSQLParserVisitor.prototype.visitOpt_equal = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterdatabasestmt. +PostgreSQLParserVisitor.prototype.visitAlterdatabasestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterdatabasesetstmt. +PostgreSQLParserVisitor.prototype.visitAlterdatabasesetstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#dropdbstmt. +PostgreSQLParserVisitor.prototype.visitDropdbstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#drop_option_list. +PostgreSQLParserVisitor.prototype.visitDrop_option_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#drop_option. +PostgreSQLParserVisitor.prototype.visitDrop_option = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altercollationstmt. +PostgreSQLParserVisitor.prototype.visitAltercollationstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altersystemstmt. +PostgreSQLParserVisitor.prototype.visitAltersystemstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createdomainstmt. +PostgreSQLParserVisitor.prototype.visitCreatedomainstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alterdomainstmt. +PostgreSQLParserVisitor.prototype.visitAlterdomainstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_as. +PostgreSQLParserVisitor.prototype.visitOpt_as = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altertsdictionarystmt. +PostgreSQLParserVisitor.prototype.visitAltertsdictionarystmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#altertsconfigurationstmt. +PostgreSQLParserVisitor.prototype.visitAltertsconfigurationstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#any_with. +PostgreSQLParserVisitor.prototype.visitAny_with = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#createconversionstmt. +PostgreSQLParserVisitor.prototype.visitCreateconversionstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#clusterstmt. +PostgreSQLParserVisitor.prototype.visitClusterstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#cluster_index_specification. +PostgreSQLParserVisitor.prototype.visitCluster_index_specification = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#vacuumstmt. +PostgreSQLParserVisitor.prototype.visitVacuumstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#analyzestmt. +PostgreSQLParserVisitor.prototype.visitAnalyzestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#vac_analyze_option_list. +PostgreSQLParserVisitor.prototype.visitVac_analyze_option_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#analyze_keyword. +PostgreSQLParserVisitor.prototype.visitAnalyze_keyword = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#vac_analyze_option_elem. +PostgreSQLParserVisitor.prototype.visitVac_analyze_option_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#vac_analyze_option_name. +PostgreSQLParserVisitor.prototype.visitVac_analyze_option_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#vac_analyze_option_arg. +PostgreSQLParserVisitor.prototype.visitVac_analyze_option_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_analyze. +PostgreSQLParserVisitor.prototype.visitOpt_analyze = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_verbose. +PostgreSQLParserVisitor.prototype.visitOpt_verbose = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_full. +PostgreSQLParserVisitor.prototype.visitOpt_full = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_freeze. +PostgreSQLParserVisitor.prototype.visitOpt_freeze = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_name_list. +PostgreSQLParserVisitor.prototype.visitOpt_name_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#vacuum_relation. +PostgreSQLParserVisitor.prototype.visitVacuum_relation = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#vacuum_relation_list. +PostgreSQLParserVisitor.prototype.visitVacuum_relation_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_vacuum_relation_list. +PostgreSQLParserVisitor.prototype.visitOpt_vacuum_relation_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#explainstmt. +PostgreSQLParserVisitor.prototype.visitExplainstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#explainablestmt. +PostgreSQLParserVisitor.prototype.visitExplainablestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#explain_option_list. +PostgreSQLParserVisitor.prototype.visitExplain_option_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#explain_option_elem. +PostgreSQLParserVisitor.prototype.visitExplain_option_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#explain_option_name. +PostgreSQLParserVisitor.prototype.visitExplain_option_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#explain_option_arg. +PostgreSQLParserVisitor.prototype.visitExplain_option_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#preparestmt. +PostgreSQLParserVisitor.prototype.visitPreparestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#prep_type_clause. +PostgreSQLParserVisitor.prototype.visitPrep_type_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#preparablestmt. +PostgreSQLParserVisitor.prototype.visitPreparablestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#executestmt. +PostgreSQLParserVisitor.prototype.visitExecutestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#execute_param_clause. +PostgreSQLParserVisitor.prototype.visitExecute_param_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#deallocatestmt. +PostgreSQLParserVisitor.prototype.visitDeallocatestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#insertstmt. +PostgreSQLParserVisitor.prototype.visitInsertstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#insert_target. +PostgreSQLParserVisitor.prototype.visitInsert_target = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#insert_rest. +PostgreSQLParserVisitor.prototype.visitInsert_rest = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#override_kind. +PostgreSQLParserVisitor.prototype.visitOverride_kind = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#insert_column_list. +PostgreSQLParserVisitor.prototype.visitInsert_column_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#insert_column_item. +PostgreSQLParserVisitor.prototype.visitInsert_column_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_on_conflict. +PostgreSQLParserVisitor.prototype.visitOpt_on_conflict = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_conf_expr. +PostgreSQLParserVisitor.prototype.visitOpt_conf_expr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#returning_clause. +PostgreSQLParserVisitor.prototype.visitReturning_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#deletestmt. +PostgreSQLParserVisitor.prototype.visitDeletestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#using_clause. +PostgreSQLParserVisitor.prototype.visitUsing_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#lockstmt. +PostgreSQLParserVisitor.prototype.visitLockstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_lock. +PostgreSQLParserVisitor.prototype.visitOpt_lock = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#lock_type. +PostgreSQLParserVisitor.prototype.visitLock_type = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_nowait. +PostgreSQLParserVisitor.prototype.visitOpt_nowait = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_nowait_or_skip. +PostgreSQLParserVisitor.prototype.visitOpt_nowait_or_skip = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#updatestmt. +PostgreSQLParserVisitor.prototype.visitUpdatestmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#set_clause_list. +PostgreSQLParserVisitor.prototype.visitSet_clause_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#set_clause. +PostgreSQLParserVisitor.prototype.visitSet_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#set_target. +PostgreSQLParserVisitor.prototype.visitSet_target = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#set_target_list. +PostgreSQLParserVisitor.prototype.visitSet_target_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#declarecursorstmt. +PostgreSQLParserVisitor.prototype.visitDeclarecursorstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#cursor_name. +PostgreSQLParserVisitor.prototype.visitCursor_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#cursor_options. +PostgreSQLParserVisitor.prototype.visitCursor_options = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_hold. +PostgreSQLParserVisitor.prototype.visitOpt_hold = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#selectstmt. +PostgreSQLParserVisitor.prototype.visitSelectstmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#select_with_parens. +PostgreSQLParserVisitor.prototype.visitSelect_with_parens = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#select_no_parens. +PostgreSQLParserVisitor.prototype.visitSelect_no_parens = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#select_clause. +PostgreSQLParserVisitor.prototype.visitSelect_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#simple_select. +PostgreSQLParserVisitor.prototype.visitSimple_select = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#union. +PostgreSQLParserVisitor.prototype.visitUnion = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#intersect. +PostgreSQLParserVisitor.prototype.visitIntersect = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#except. +PostgreSQLParserVisitor.prototype.visitExcept = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#set_operator_with_all_or_distinct. +PostgreSQLParserVisitor.prototype.visitSet_operator_with_all_or_distinct = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#with_clause. +PostgreSQLParserVisitor.prototype.visitWith_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#cte_list. +PostgreSQLParserVisitor.prototype.visitCte_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#common_table_expr. +PostgreSQLParserVisitor.prototype.visitCommon_table_expr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_materialized. +PostgreSQLParserVisitor.prototype.visitOpt_materialized = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_with_clause. +PostgreSQLParserVisitor.prototype.visitOpt_with_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#into_clause. +PostgreSQLParserVisitor.prototype.visitInto_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_strict. +PostgreSQLParserVisitor.prototype.visitOpt_strict = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opttempTableName. +PostgreSQLParserVisitor.prototype.visitOpttempTableName = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_table. +PostgreSQLParserVisitor.prototype.visitOpt_table = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#all_or_distinct. +PostgreSQLParserVisitor.prototype.visitAll_or_distinct = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#distinct_clause. +PostgreSQLParserVisitor.prototype.visitDistinct_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_all_clause. +PostgreSQLParserVisitor.prototype.visitOpt_all_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_sort_clause. +PostgreSQLParserVisitor.prototype.visitOpt_sort_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#sort_clause. +PostgreSQLParserVisitor.prototype.visitSort_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#sortby_list. +PostgreSQLParserVisitor.prototype.visitSortby_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#sortby. +PostgreSQLParserVisitor.prototype.visitSortby = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#select_limit. +PostgreSQLParserVisitor.prototype.visitSelect_limit = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_select_limit. +PostgreSQLParserVisitor.prototype.visitOpt_select_limit = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#limit_clause. +PostgreSQLParserVisitor.prototype.visitLimit_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#offset_clause. +PostgreSQLParserVisitor.prototype.visitOffset_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#select_limit_value. +PostgreSQLParserVisitor.prototype.visitSelect_limit_value = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#select_offset_value. +PostgreSQLParserVisitor.prototype.visitSelect_offset_value = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#select_fetch_first_value. +PostgreSQLParserVisitor.prototype.visitSelect_fetch_first_value = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#i_or_f_const. +PostgreSQLParserVisitor.prototype.visitI_or_f_const = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#row_or_rows. +PostgreSQLParserVisitor.prototype.visitRow_or_rows = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#first_or_next. +PostgreSQLParserVisitor.prototype.visitFirst_or_next = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#group_clause. +PostgreSQLParserVisitor.prototype.visitGroup_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#group_by_list. +PostgreSQLParserVisitor.prototype.visitGroup_by_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#group_by_item. +PostgreSQLParserVisitor.prototype.visitGroup_by_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#empty_grouping_set. +PostgreSQLParserVisitor.prototype.visitEmpty_grouping_set = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rollup_clause. +PostgreSQLParserVisitor.prototype.visitRollup_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#cube_clause. +PostgreSQLParserVisitor.prototype.visitCube_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#grouping_sets_clause. +PostgreSQLParserVisitor.prototype.visitGrouping_sets_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#having_clause. +PostgreSQLParserVisitor.prototype.visitHaving_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#for_locking_clause. +PostgreSQLParserVisitor.prototype.visitFor_locking_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_for_locking_clause. +PostgreSQLParserVisitor.prototype.visitOpt_for_locking_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#for_locking_items. +PostgreSQLParserVisitor.prototype.visitFor_locking_items = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#for_locking_item. +PostgreSQLParserVisitor.prototype.visitFor_locking_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#for_locking_strength. +PostgreSQLParserVisitor.prototype.visitFor_locking_strength = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#locked_rels_list. +PostgreSQLParserVisitor.prototype.visitLocked_rels_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#values_clause. +PostgreSQLParserVisitor.prototype.visitValues_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#from_clause. +PostgreSQLParserVisitor.prototype.visitFrom_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#from_list. +PostgreSQLParserVisitor.prototype.visitFrom_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#table_ref. +PostgreSQLParserVisitor.prototype.visitTable_ref = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#alias_clause. +PostgreSQLParserVisitor.prototype.visitAlias_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_alias_clause. +PostgreSQLParserVisitor.prototype.visitOpt_alias_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_alias_clause. +PostgreSQLParserVisitor.prototype.visitFunc_alias_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#join_type. +PostgreSQLParserVisitor.prototype.visitJoin_type = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#join_qual. +PostgreSQLParserVisitor.prototype.visitJoin_qual = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#relation_expr. +PostgreSQLParserVisitor.prototype.visitRelation_expr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#relation_expr_list. +PostgreSQLParserVisitor.prototype.visitRelation_expr_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#relation_expr_opt_alias. +PostgreSQLParserVisitor.prototype.visitRelation_expr_opt_alias = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#tablesample_clause. +PostgreSQLParserVisitor.prototype.visitTablesample_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_repeatable_clause. +PostgreSQLParserVisitor.prototype.visitOpt_repeatable_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_table. +PostgreSQLParserVisitor.prototype.visitFunc_table = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rowsfrom_item. +PostgreSQLParserVisitor.prototype.visitRowsfrom_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rowsfrom_list. +PostgreSQLParserVisitor.prototype.visitRowsfrom_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_col_def_list. +PostgreSQLParserVisitor.prototype.visitOpt_col_def_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_ordinality. +PostgreSQLParserVisitor.prototype.visitOpt_ordinality = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#where_clause. +PostgreSQLParserVisitor.prototype.visitWhere_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#where_or_current_clause. +PostgreSQLParserVisitor.prototype.visitWhere_or_current_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opttablefuncelementlist. +PostgreSQLParserVisitor.prototype.visitOpttablefuncelementlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#tablefuncelementlist. +PostgreSQLParserVisitor.prototype.visitTablefuncelementlist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#tablefuncelement. +PostgreSQLParserVisitor.prototype.visitTablefuncelement = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xmltable. +PostgreSQLParserVisitor.prototype.visitXmltable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xmltable_column_list. +PostgreSQLParserVisitor.prototype.visitXmltable_column_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xmltable_column_el. +PostgreSQLParserVisitor.prototype.visitXmltable_column_el = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xmltable_column_option_list. +PostgreSQLParserVisitor.prototype.visitXmltable_column_option_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xmltable_column_option_el. +PostgreSQLParserVisitor.prototype.visitXmltable_column_option_el = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xml_namespace_list. +PostgreSQLParserVisitor.prototype.visitXml_namespace_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xml_namespace_el. +PostgreSQLParserVisitor.prototype.visitXml_namespace_el = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#typename. +PostgreSQLParserVisitor.prototype.visitTypename = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_array_bounds. +PostgreSQLParserVisitor.prototype.visitOpt_array_bounds = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#simpletypename. +PostgreSQLParserVisitor.prototype.visitSimpletypename = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#consttypename. +PostgreSQLParserVisitor.prototype.visitConsttypename = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#generictype. +PostgreSQLParserVisitor.prototype.visitGenerictype = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_type_modifiers. +PostgreSQLParserVisitor.prototype.visitOpt_type_modifiers = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#numeric. +PostgreSQLParserVisitor.prototype.visitNumeric = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_float. +PostgreSQLParserVisitor.prototype.visitOpt_float = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#bit. +PostgreSQLParserVisitor.prototype.visitBit = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constbit. +PostgreSQLParserVisitor.prototype.visitConstbit = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#bitwithlength. +PostgreSQLParserVisitor.prototype.visitBitwithlength = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#bitwithoutlength. +PostgreSQLParserVisitor.prototype.visitBitwithoutlength = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#character. +PostgreSQLParserVisitor.prototype.visitCharacter = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constcharacter. +PostgreSQLParserVisitor.prototype.visitConstcharacter = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#character_c. +PostgreSQLParserVisitor.prototype.visitCharacter_c = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_varying. +PostgreSQLParserVisitor.prototype.visitOpt_varying = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constdatetime. +PostgreSQLParserVisitor.prototype.visitConstdatetime = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#constinterval. +PostgreSQLParserVisitor.prototype.visitConstinterval = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_timezone. +PostgreSQLParserVisitor.prototype.visitOpt_timezone = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_interval. +PostgreSQLParserVisitor.prototype.visitOpt_interval = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#interval_second. +PostgreSQLParserVisitor.prototype.visitInterval_second = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_escape. +PostgreSQLParserVisitor.prototype.visitOpt_escape = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr. +PostgreSQLParserVisitor.prototype.visitA_expr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_qual. +PostgreSQLParserVisitor.prototype.visitA_expr_qual = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_lessless. +PostgreSQLParserVisitor.prototype.visitA_expr_lessless = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_or. +PostgreSQLParserVisitor.prototype.visitA_expr_or = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_and. +PostgreSQLParserVisitor.prototype.visitA_expr_and = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_in. +PostgreSQLParserVisitor.prototype.visitA_expr_in = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_unary_not. +PostgreSQLParserVisitor.prototype.visitA_expr_unary_not = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_isnull. +PostgreSQLParserVisitor.prototype.visitA_expr_isnull = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_is_not. +PostgreSQLParserVisitor.prototype.visitA_expr_is_not = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_compare. +PostgreSQLParserVisitor.prototype.visitA_expr_compare = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_like. +PostgreSQLParserVisitor.prototype.visitA_expr_like = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_qual_op. +PostgreSQLParserVisitor.prototype.visitA_expr_qual_op = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_unary_qualop. +PostgreSQLParserVisitor.prototype.visitA_expr_unary_qualop = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_add. +PostgreSQLParserVisitor.prototype.visitA_expr_add = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_mul. +PostgreSQLParserVisitor.prototype.visitA_expr_mul = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_caret. +PostgreSQLParserVisitor.prototype.visitA_expr_caret = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_unary_sign. +PostgreSQLParserVisitor.prototype.visitA_expr_unary_sign = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_at_time_zone. +PostgreSQLParserVisitor.prototype.visitA_expr_at_time_zone = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_collate. +PostgreSQLParserVisitor.prototype.visitA_expr_collate = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#a_expr_typecast. +PostgreSQLParserVisitor.prototype.visitA_expr_typecast = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#b_expr. +PostgreSQLParserVisitor.prototype.visitB_expr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#c_expr_exists. +PostgreSQLParserVisitor.prototype.visitC_expr_exists = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#c_expr_expr. +PostgreSQLParserVisitor.prototype.visitC_expr_expr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#c_expr_case. +PostgreSQLParserVisitor.prototype.visitC_expr_case = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#plsqlvariablename. +PostgreSQLParserVisitor.prototype.visitPlsqlvariablename = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_application. +PostgreSQLParserVisitor.prototype.visitFunc_application = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_expr. +PostgreSQLParserVisitor.prototype.visitFunc_expr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_expr_windowless. +PostgreSQLParserVisitor.prototype.visitFunc_expr_windowless = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_expr_common_subexpr. +PostgreSQLParserVisitor.prototype.visitFunc_expr_common_subexpr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xml_root_version. +PostgreSQLParserVisitor.prototype.visitXml_root_version = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_xml_root_standalone. +PostgreSQLParserVisitor.prototype.visitOpt_xml_root_standalone = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xml_attributes. +PostgreSQLParserVisitor.prototype.visitXml_attributes = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xml_attribute_list. +PostgreSQLParserVisitor.prototype.visitXml_attribute_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xml_attribute_el. +PostgreSQLParserVisitor.prototype.visitXml_attribute_el = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#document_or_content. +PostgreSQLParserVisitor.prototype.visitDocument_or_content = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xml_whitespace_option. +PostgreSQLParserVisitor.prototype.visitXml_whitespace_option = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xmlexists_argument. +PostgreSQLParserVisitor.prototype.visitXmlexists_argument = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xml_passing_mech. +PostgreSQLParserVisitor.prototype.visitXml_passing_mech = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#within_group_clause. +PostgreSQLParserVisitor.prototype.visitWithin_group_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#filter_clause. +PostgreSQLParserVisitor.prototype.visitFilter_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#window_clause. +PostgreSQLParserVisitor.prototype.visitWindow_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#window_definition_list. +PostgreSQLParserVisitor.prototype.visitWindow_definition_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#window_definition. +PostgreSQLParserVisitor.prototype.visitWindow_definition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#over_clause. +PostgreSQLParserVisitor.prototype.visitOver_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#window_specification. +PostgreSQLParserVisitor.prototype.visitWindow_specification = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_existing_window_name. +PostgreSQLParserVisitor.prototype.visitOpt_existing_window_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_partition_clause. +PostgreSQLParserVisitor.prototype.visitOpt_partition_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_frame_clause. +PostgreSQLParserVisitor.prototype.visitOpt_frame_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#frame_extent. +PostgreSQLParserVisitor.prototype.visitFrame_extent = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#frame_bound. +PostgreSQLParserVisitor.prototype.visitFrame_bound = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_window_exclusion_clause. +PostgreSQLParserVisitor.prototype.visitOpt_window_exclusion_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#row. +PostgreSQLParserVisitor.prototype.visitRow = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#explicit_row. +PostgreSQLParserVisitor.prototype.visitExplicit_row = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#implicit_row. +PostgreSQLParserVisitor.prototype.visitImplicit_row = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#sub_type. +PostgreSQLParserVisitor.prototype.visitSub_type = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#all_op. +PostgreSQLParserVisitor.prototype.visitAll_op = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#mathop. +PostgreSQLParserVisitor.prototype.visitMathop = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#qual_op. +PostgreSQLParserVisitor.prototype.visitQual_op = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#qual_all_op. +PostgreSQLParserVisitor.prototype.visitQual_all_op = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#subquery_Op. +PostgreSQLParserVisitor.prototype.visitSubquery_Op = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#expr_list. +PostgreSQLParserVisitor.prototype.visitExpr_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_arg_list. +PostgreSQLParserVisitor.prototype.visitFunc_arg_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_arg_expr. +PostgreSQLParserVisitor.prototype.visitFunc_arg_expr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#type_list. +PostgreSQLParserVisitor.prototype.visitType_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#array_expr. +PostgreSQLParserVisitor.prototype.visitArray_expr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#array_expr_list. +PostgreSQLParserVisitor.prototype.visitArray_expr_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#extract_list. +PostgreSQLParserVisitor.prototype.visitExtract_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#extract_arg. +PostgreSQLParserVisitor.prototype.visitExtract_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#unicode_normal_form. +PostgreSQLParserVisitor.prototype.visitUnicode_normal_form = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#overlay_list. +PostgreSQLParserVisitor.prototype.visitOverlay_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#position_list. +PostgreSQLParserVisitor.prototype.visitPosition_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#substr_list. +PostgreSQLParserVisitor.prototype.visitSubstr_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#trim_list. +PostgreSQLParserVisitor.prototype.visitTrim_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#in_expr_select. +PostgreSQLParserVisitor.prototype.visitIn_expr_select = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#in_expr_list. +PostgreSQLParserVisitor.prototype.visitIn_expr_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#case_expr. +PostgreSQLParserVisitor.prototype.visitCase_expr = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#when_clause_list. +PostgreSQLParserVisitor.prototype.visitWhen_clause_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#when_clause. +PostgreSQLParserVisitor.prototype.visitWhen_clause = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#case_default. +PostgreSQLParserVisitor.prototype.visitCase_default = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#case_arg. +PostgreSQLParserVisitor.prototype.visitCase_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#columnref. +PostgreSQLParserVisitor.prototype.visitColumnref = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#indirection_el. +PostgreSQLParserVisitor.prototype.visitIndirection_el = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_slice_bound. +PostgreSQLParserVisitor.prototype.visitOpt_slice_bound = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#indirection. +PostgreSQLParserVisitor.prototype.visitIndirection = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_indirection. +PostgreSQLParserVisitor.prototype.visitOpt_indirection = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_target_list. +PostgreSQLParserVisitor.prototype.visitOpt_target_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#target_list. +PostgreSQLParserVisitor.prototype.visitTarget_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#target_label. +PostgreSQLParserVisitor.prototype.visitTarget_label = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#target_star. +PostgreSQLParserVisitor.prototype.visitTarget_star = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#qualified_name_list. +PostgreSQLParserVisitor.prototype.visitQualified_name_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#qualified_name. +PostgreSQLParserVisitor.prototype.visitQualified_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#name_list. +PostgreSQLParserVisitor.prototype.visitName_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#name. +PostgreSQLParserVisitor.prototype.visitName = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#attr_name. +PostgreSQLParserVisitor.prototype.visitAttr_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#file_name. +PostgreSQLParserVisitor.prototype.visitFile_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#func_name. +PostgreSQLParserVisitor.prototype.visitFunc_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#aexprconst. +PostgreSQLParserVisitor.prototype.visitAexprconst = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#xconst. +PostgreSQLParserVisitor.prototype.visitXconst = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#bconst. +PostgreSQLParserVisitor.prototype.visitBconst = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#fconst. +PostgreSQLParserVisitor.prototype.visitFconst = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#iconst. +PostgreSQLParserVisitor.prototype.visitIconst = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#sconst. +PostgreSQLParserVisitor.prototype.visitSconst = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#anysconst. +PostgreSQLParserVisitor.prototype.visitAnysconst = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_uescape. +PostgreSQLParserVisitor.prototype.visitOpt_uescape = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#signediconst. +PostgreSQLParserVisitor.prototype.visitSignediconst = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#roleid. +PostgreSQLParserVisitor.prototype.visitRoleid = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#rolespec. +PostgreSQLParserVisitor.prototype.visitRolespec = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#role_list. +PostgreSQLParserVisitor.prototype.visitRole_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#colid. +PostgreSQLParserVisitor.prototype.visitColid = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#type_function_name. +PostgreSQLParserVisitor.prototype.visitType_function_name = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#nonreservedword. +PostgreSQLParserVisitor.prototype.visitNonreservedword = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#collabel. +PostgreSQLParserVisitor.prototype.visitCollabel = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#identifier. +PostgreSQLParserVisitor.prototype.visitIdentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#plsqlidentifier. +PostgreSQLParserVisitor.prototype.visitPlsqlidentifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#unreserved_keyword. +PostgreSQLParserVisitor.prototype.visitUnreserved_keyword = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#col_name_keyword. +PostgreSQLParserVisitor.prototype.visitCol_name_keyword = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#type_func_name_keyword. +PostgreSQLParserVisitor.prototype.visitType_func_name_keyword = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#reserved_keyword. +PostgreSQLParserVisitor.prototype.visitReserved_keyword = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#pl_function. +PostgreSQLParserVisitor.prototype.visitPl_function = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#comp_options. +PostgreSQLParserVisitor.prototype.visitComp_options = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#comp_option. +PostgreSQLParserVisitor.prototype.visitComp_option = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#sharp. +PostgreSQLParserVisitor.prototype.visitSharp = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#option_value. +PostgreSQLParserVisitor.prototype.visitOption_value = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_semi. +PostgreSQLParserVisitor.prototype.visitOpt_semi = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#pl_block. +PostgreSQLParserVisitor.prototype.visitPl_block = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_sect. +PostgreSQLParserVisitor.prototype.visitDecl_sect = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_start. +PostgreSQLParserVisitor.prototype.visitDecl_start = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_stmts. +PostgreSQLParserVisitor.prototype.visitDecl_stmts = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#label_decl. +PostgreSQLParserVisitor.prototype.visitLabel_decl = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_stmt. +PostgreSQLParserVisitor.prototype.visitDecl_stmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_statement. +PostgreSQLParserVisitor.prototype.visitDecl_statement = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_scrollable. +PostgreSQLParserVisitor.prototype.visitOpt_scrollable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_cursor_query. +PostgreSQLParserVisitor.prototype.visitDecl_cursor_query = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_cursor_args. +PostgreSQLParserVisitor.prototype.visitDecl_cursor_args = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_cursor_arglist. +PostgreSQLParserVisitor.prototype.visitDecl_cursor_arglist = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_cursor_arg. +PostgreSQLParserVisitor.prototype.visitDecl_cursor_arg = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_is_for. +PostgreSQLParserVisitor.prototype.visitDecl_is_for = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_aliasitem. +PostgreSQLParserVisitor.prototype.visitDecl_aliasitem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_varname. +PostgreSQLParserVisitor.prototype.visitDecl_varname = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_const. +PostgreSQLParserVisitor.prototype.visitDecl_const = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_datatype. +PostgreSQLParserVisitor.prototype.visitDecl_datatype = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_collate. +PostgreSQLParserVisitor.prototype.visitDecl_collate = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_notnull. +PostgreSQLParserVisitor.prototype.visitDecl_notnull = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_defval. +PostgreSQLParserVisitor.prototype.visitDecl_defval = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#decl_defkey. +PostgreSQLParserVisitor.prototype.visitDecl_defkey = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#assign_operator. +PostgreSQLParserVisitor.prototype.visitAssign_operator = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#proc_sect. +PostgreSQLParserVisitor.prototype.visitProc_sect = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#proc_stmt. +PostgreSQLParserVisitor.prototype.visitProc_stmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_perform. +PostgreSQLParserVisitor.prototype.visitStmt_perform = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_call. +PostgreSQLParserVisitor.prototype.visitStmt_call = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_expr_list. +PostgreSQLParserVisitor.prototype.visitOpt_expr_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_assign. +PostgreSQLParserVisitor.prototype.visitStmt_assign = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_getdiag. +PostgreSQLParserVisitor.prototype.visitStmt_getdiag = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#getdiag_area_opt. +PostgreSQLParserVisitor.prototype.visitGetdiag_area_opt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#getdiag_list. +PostgreSQLParserVisitor.prototype.visitGetdiag_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#getdiag_list_item. +PostgreSQLParserVisitor.prototype.visitGetdiag_list_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#getdiag_item. +PostgreSQLParserVisitor.prototype.visitGetdiag_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#getdiag_target. +PostgreSQLParserVisitor.prototype.visitGetdiag_target = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#assign_var. +PostgreSQLParserVisitor.prototype.visitAssign_var = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_if. +PostgreSQLParserVisitor.prototype.visitStmt_if = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_elsifs. +PostgreSQLParserVisitor.prototype.visitStmt_elsifs = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_else. +PostgreSQLParserVisitor.prototype.visitStmt_else = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_case. +PostgreSQLParserVisitor.prototype.visitStmt_case = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_expr_until_when. +PostgreSQLParserVisitor.prototype.visitOpt_expr_until_when = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#case_when_list. +PostgreSQLParserVisitor.prototype.visitCase_when_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#case_when. +PostgreSQLParserVisitor.prototype.visitCase_when = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_case_else. +PostgreSQLParserVisitor.prototype.visitOpt_case_else = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_loop. +PostgreSQLParserVisitor.prototype.visitStmt_loop = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_while. +PostgreSQLParserVisitor.prototype.visitStmt_while = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_for. +PostgreSQLParserVisitor.prototype.visitStmt_for = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#for_control. +PostgreSQLParserVisitor.prototype.visitFor_control = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_for_using_expression. +PostgreSQLParserVisitor.prototype.visitOpt_for_using_expression = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_cursor_parameters. +PostgreSQLParserVisitor.prototype.visitOpt_cursor_parameters = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_reverse. +PostgreSQLParserVisitor.prototype.visitOpt_reverse = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_by_expression. +PostgreSQLParserVisitor.prototype.visitOpt_by_expression = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#for_variable. +PostgreSQLParserVisitor.prototype.visitFor_variable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_foreach_a. +PostgreSQLParserVisitor.prototype.visitStmt_foreach_a = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#foreach_slice. +PostgreSQLParserVisitor.prototype.visitForeach_slice = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_exit. +PostgreSQLParserVisitor.prototype.visitStmt_exit = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#exit_type. +PostgreSQLParserVisitor.prototype.visitExit_type = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_return. +PostgreSQLParserVisitor.prototype.visitStmt_return = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_return_result. +PostgreSQLParserVisitor.prototype.visitOpt_return_result = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_raise. +PostgreSQLParserVisitor.prototype.visitStmt_raise = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_stmt_raise_level. +PostgreSQLParserVisitor.prototype.visitOpt_stmt_raise_level = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_raise_list. +PostgreSQLParserVisitor.prototype.visitOpt_raise_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_raise_using. +PostgreSQLParserVisitor.prototype.visitOpt_raise_using = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_raise_using_elem. +PostgreSQLParserVisitor.prototype.visitOpt_raise_using_elem = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_raise_using_elem_list. +PostgreSQLParserVisitor.prototype.visitOpt_raise_using_elem_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_assert. +PostgreSQLParserVisitor.prototype.visitStmt_assert = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_stmt_assert_message. +PostgreSQLParserVisitor.prototype.visitOpt_stmt_assert_message = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#loop_body. +PostgreSQLParserVisitor.prototype.visitLoop_body = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_execsql. +PostgreSQLParserVisitor.prototype.visitStmt_execsql = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_dynexecute. +PostgreSQLParserVisitor.prototype.visitStmt_dynexecute = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_execute_using. +PostgreSQLParserVisitor.prototype.visitOpt_execute_using = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_execute_using_list. +PostgreSQLParserVisitor.prototype.visitOpt_execute_using_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_execute_into. +PostgreSQLParserVisitor.prototype.visitOpt_execute_into = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_open. +PostgreSQLParserVisitor.prototype.visitStmt_open = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_open_bound_list_item. +PostgreSQLParserVisitor.prototype.visitOpt_open_bound_list_item = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_open_bound_list. +PostgreSQLParserVisitor.prototype.visitOpt_open_bound_list = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_open_using. +PostgreSQLParserVisitor.prototype.visitOpt_open_using = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_scroll_option. +PostgreSQLParserVisitor.prototype.visitOpt_scroll_option = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_scroll_option_no. +PostgreSQLParserVisitor.prototype.visitOpt_scroll_option_no = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_fetch. +PostgreSQLParserVisitor.prototype.visitStmt_fetch = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#into_target. +PostgreSQLParserVisitor.prototype.visitInto_target = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_cursor_from. +PostgreSQLParserVisitor.prototype.visitOpt_cursor_from = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_fetch_direction. +PostgreSQLParserVisitor.prototype.visitOpt_fetch_direction = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_move. +PostgreSQLParserVisitor.prototype.visitStmt_move = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_close. +PostgreSQLParserVisitor.prototype.visitStmt_close = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_null. +PostgreSQLParserVisitor.prototype.visitStmt_null = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_commit. +PostgreSQLParserVisitor.prototype.visitStmt_commit = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_rollback. +PostgreSQLParserVisitor.prototype.visitStmt_rollback = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#plsql_opt_transaction_chain. +PostgreSQLParserVisitor.prototype.visitPlsql_opt_transaction_chain = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#stmt_set. +PostgreSQLParserVisitor.prototype.visitStmt_set = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#cursor_variable. +PostgreSQLParserVisitor.prototype.visitCursor_variable = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#exception_sect. +PostgreSQLParserVisitor.prototype.visitException_sect = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#proc_exceptions. +PostgreSQLParserVisitor.prototype.visitProc_exceptions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#proc_exception. +PostgreSQLParserVisitor.prototype.visitProc_exception = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#proc_conditions. +PostgreSQLParserVisitor.prototype.visitProc_conditions = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#proc_condition. +PostgreSQLParserVisitor.prototype.visitProc_condition = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_block_label. +PostgreSQLParserVisitor.prototype.visitOpt_block_label = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_loop_label. +PostgreSQLParserVisitor.prototype.visitOpt_loop_label = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_label. +PostgreSQLParserVisitor.prototype.visitOpt_label = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_exitcond. +PostgreSQLParserVisitor.prototype.visitOpt_exitcond = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#any_identifier. +PostgreSQLParserVisitor.prototype.visitAny_identifier = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#plsql_unreserved_keyword. +PostgreSQLParserVisitor.prototype.visitPlsql_unreserved_keyword = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#sql_expression. +PostgreSQLParserVisitor.prototype.visitSql_expression = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#expr_until_then. +PostgreSQLParserVisitor.prototype.visitExpr_until_then = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#expr_until_semi. +PostgreSQLParserVisitor.prototype.visitExpr_until_semi = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#expr_until_rightbracket. +PostgreSQLParserVisitor.prototype.visitExpr_until_rightbracket = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#expr_until_loop. +PostgreSQLParserVisitor.prototype.visitExpr_until_loop = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#make_execsql_stmt. +PostgreSQLParserVisitor.prototype.visitMake_execsql_stmt = function(ctx) { + return this.visitChildren(ctx); +}; + + +// Visit a parse tree produced by PostgreSQLParser#opt_returning_clause_into. +PostgreSQLParserVisitor.prototype.visitOpt_returning_clause_into = function(ctx) { + return this.visitChildren(ctx); +}; + + + +exports.PostgreSQLParserVisitor = PostgreSQLParserVisitor; \ No newline at end of file diff --git a/src/lib/pgsql/base/LexerDispatchingErrorListener.java b/src/lib/pgsql/base/LexerDispatchingErrorListener.java new file mode 100644 index 0000000..a29f7f8 --- /dev/null +++ b/src/lib/pgsql/base/LexerDispatchingErrorListener.java @@ -0,0 +1,55 @@ +import java.util.BitSet; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.*; +import org.antlr.v4.runtime.misc.*; + +public class LexerDispatchingErrorListener implements ANTLRErrorListener +{ + Lexer _parent; + + public LexerDispatchingErrorListener(Lexer parent) + { + _parent = parent; + } + + public void syntaxError(Recognizer recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) + { + var foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e); + } + + public void reportAmbiguity(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + boolean exact, + BitSet ambigAlts, + ATNConfigSet configs) + { + var foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs); + } + + public void reportAttemptingFullContext(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + BitSet conflictingAlts, + ATNConfigSet configs) + { + var foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs); + } + + public void reportContextSensitivity(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + int prediction, + ATNConfigSet configs) + { + var foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs); + } +} diff --git a/src/lib/pgsql/base/ParserDispatchingErrorListener.java b/src/lib/pgsql/base/ParserDispatchingErrorListener.java new file mode 100644 index 0000000..e1aceb4 --- /dev/null +++ b/src/lib/pgsql/base/ParserDispatchingErrorListener.java @@ -0,0 +1,55 @@ +import java.util.BitSet; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.*; +import org.antlr.v4.runtime.misc.*; + +public class ParserDispatchingErrorListener implements ANTLRErrorListener +{ + Parser _parent; + + public ParserDispatchingErrorListener(Parser parent) + { + _parent = parent; + } + + public void syntaxError(Recognizer recognizer, Object offendingSymbol, int line, int charPositionInLine, String msg, RecognitionException e) + { + var foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.syntaxError(recognizer, offendingSymbol, line, charPositionInLine, msg, e); + } + + public void reportAmbiguity(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + boolean exact, + BitSet ambigAlts, + ATNConfigSet configs) + { + var foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs); + } + + public void reportAttemptingFullContext(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + BitSet conflictingAlts, + ATNConfigSet configs) + { + var foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs); + } + + public void reportContextSensitivity(Parser recognizer, + DFA dfa, + int startIndex, + int stopIndex, + int prediction, + ATNConfigSet configs) + { + var foo = new ProxyErrorListener(_parent.getErrorListeners()); + foo.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs); + } +} diff --git a/src/lib/pgsql/base/PostgreSQLLexerBase.js b/src/lib/pgsql/base/PostgreSQLLexerBase.js new file mode 100644 index 0000000..6d2672b --- /dev/null +++ b/src/lib/pgsql/base/PostgreSQLLexerBase.js @@ -0,0 +1,67 @@ +const antlr4 = require('antlr4/index'); +const Lexer = antlr4.Lexer; +function isLetter(str) { + return str.length === 1 && str.match(/[a-z]/i); +} +export class PostgreSQLLexerBase extends Lexer { + tags = []; + + constructor(input) { + super(input); + } + + pushTag() { + this.tags.push(getText()); + } + + isTag() { + return this.getText().equals(this.tags.peek()); + } + + popTag() { + tags.pop(); + } + + getInputStream() { + return this._input; + } + checkLA( c) { + // eslint-disable-next-line new-cap + return this.getInputStream().LA(1) !== c; + } + + charIsLetter() { + // eslint-disable-next-line new-cap + return isLetter(this.getInputStream().LA(-1)); + } + + HandleNumericFail() { + this.getInputStream().seek(this.getInputStream().index() - 2); + const Integral = 535; + this.setType(Integral); + } + + HandleLessLessGreaterGreater() { + const LESS_LESS = 18; + const GREATER_GREATER = 19; + if (this.getText() === '<<') this.setType(LESS_LESS); + if (this.getText() === '>>') this.setType(GREATER_GREATER); + } + + UnterminatedBlockCommentDebugAssert() { + // Debug.Assert(InputStream.LA(1) == -1 /*EOF*/); + } + + CheckIfUtf32Letter() { + // eslint-disable-next-line new-cap + let codePoint = this.getInputStream().LA(-2) << 8 + this.getInputStream().LA(-1); + let c; + if (codePoint < 0x10000) { + c = String.fromCharCode(codePoint); + } else { + codePoint -= 0x10000; + c = String.fromCharCode(codePoint / 0x400 + 0xd800, codePoint % 0x400 + 0xdc00); + } + return isLetter(c[0]); + } +} diff --git a/src/lib/pgsql/base/PostgreSQLParserBase.js b/src/lib/pgsql/base/PostgreSQLParserBase.js new file mode 100644 index 0000000..adb489e --- /dev/null +++ b/src/lib/pgsql/base/PostgreSQLParserBase.js @@ -0,0 +1,114 @@ +/* eslint-disable new-cap */ +import { PostgreSQLLexer } from '../PostgreSQLLexer'; +import { PostgreSQLParser } from '../PostgreSQLParser'; + + +const antlr4 = require('antlr4/index'); +const CharStreams = antlr4.CharStreams; +const CommonTokenStream = antlr4.CommonTokenStream; + + +// @ts-ignore +export class PostgreSQLParserBase extends antlr4.Parser { + constructor( input) { + super(input); + } + + GetParsedSqlTree( script, line) { + const ph = this.getPostgreSQLParser(script); + return ph.root(); + } + + ParseRoutineBody( _localctx) { + let lang = null; + for (const coi of _localctx.createfunc_opt_item()) { + // eslint-disable-next-line new-cap + if (!coi.LANGUAGE()) { + if (!coi.nonreservedword_or_sconst()) { + if (!coi.nonreservedword_or_sconst().nonreservedword()) { + if (!coi.nonreservedword_or_sconst().nonreservedword().identifier()) { + // eslint-disable-next-line new-cap + if (!coi.nonreservedword_or_sconst().nonreservedword().identifier().Identifier()) { + // eslint-disable-next-line new-cap + lang = coi.nonreservedword_or_sconst().nonreservedword().identifier().Identifier().getText(); + break; + } + } + } + } + } + } + if (!lang) return; + // eslint-disable-next-line camelcase + let func_as = null; + for (const a of _localctx.createfunc_opt_item()) { + if (!a.func_as()) { + // eslint-disable-next-line camelcase + func_as = a; + break; + } + } + // eslint-disable-next-line camelcase + if (!func_as) { + const txt = this.GetRoutineBodyString(func_as.func_as().sconst(0)); + const line = func_as.func_as().sconst(0).start.getLine(); + const ph = this.getPostgreSQLParser(txt); + switch (lang) { + case 'plpgsql': + func_as.func_as().Definition = ph.plsqlroot(); + break; + case 'sql': + func_as.func_as().Definition = ph.root(); + break; + } + } + } + + TrimQuotes( s) { + return (!s) ? s : s.substring(1, s.length() - 1); + } + + unquote( s) { + const slength = s.length(); + const r = ''; + let i = 0; + while (i < slength) { + const c = s.charAt(i); + r.append(c); + if (c === '\'' && i < slength - 1 && (s.charAt(i + 1) === '\'')) i++; + i++; + } + return r.toString(); + } + + GetRoutineBodyString( rule) { + const anysconst = rule.anysconst(); + // eslint-disable-next-line new-cap + const StringConstant = anysconst.StringConstant(); + if (null !== StringConstant) return this.unquote(this.TrimQuotes(StringConstant.getText())); + const UnicodeEscapeStringConstant = anysconst.UnicodeEscapeStringConstant(); + if (null !== UnicodeEscapeStringConstant) return this.TrimQuotes(UnicodeEscapeStringConstant.getText()); + const EscapeStringConstant = anysconst.EscapeStringConstant(); + if (null !== EscapeStringConstant) return this.TrimQuotes(EscapeStringConstant.getText()); + let result = ''; + const dollartext = anysconst.DollarText(); + for (const s of dollartext) { + result += s.getText(); + } + return result; + } + + static getPostgreSQLParser( script) { + const charStream = CharStreams.fromString(script); + const lexer = new PostgreSQLLexer(charStream); + const tokens = new CommonTokenStream(lexer); + const parser = new PostgreSQLParser(tokens); + lexer.removeErrorListeners(); + parser.removeErrorListeners(); + // LexerDispatchingErrorListener listener_lexer = new LexerDispatchingErrorListener((Lexer)(((CommonTokenStream)(this.getInputStream())).getTokenSource())); + // ParserDispatchingErrorListener listener_parser = new ParserDispatchingErrorListener(this); + // lexer.addErrorListener(listener_lexer); + // parser.addErrorListener(listener_parser); + return parser; + } +} diff --git a/src/parser/common/basicParser.ts b/src/parser/common/basicParser.ts index a105522..6158956 100644 --- a/src/parser/common/basicParser.ts +++ b/src/parser/common/basicParser.ts @@ -23,7 +23,8 @@ export default abstract class BasicParser { parser.removeErrorListeners(); parser.addErrorListener(new ParserErrorListener(errorListener)); - const parserTree = parser.program(); + // Note : needed by pgsql + const parserTree = parser.program? parser.program() : parser.root(); return parserTree; } @@ -37,7 +38,12 @@ export default abstract class BasicParser { parser.removeErrorListeners(); parser.addErrorListener(new ParserErrorCollector(syntaxErrors)); - parser.program(); + // Note : needed by pgsql + if (parser.program) { + parser.program(); + } else { + parser.root(); + } return lexerError.concat(syntaxErrors); } @@ -89,7 +95,8 @@ export default abstract class BasicParser { const parser = this.createParser(input); this._parser = parser; - const tree = parser.program(); + // Note : needed by pgsql + const tree = parser.program? parser.program() : parser.root(); return tree.toStringTree(parser.ruleNames); } diff --git a/src/parser/pgsql.ts b/src/parser/pgsql.ts new file mode 100644 index 0000000..61a4314 --- /dev/null +++ b/src/parser/pgsql.ts @@ -0,0 +1,17 @@ +import { InputStream, CommonTokenStream, Lexer } from 'antlr4'; +import { PostgreSQLLexer } from '../lib/pgsql/PostgreSQLLexer'; +import { PostgreSQLParser } from '../lib/pgsql/PostgreSQLParser'; + +import BasicParser from './common/basicParser'; + +export default class PLSQLParser extends BasicParser { + public createLexer(input: string): Lexer { + const chars = new InputStream(input.toUpperCase()); + const lexer = new PostgreSQLLexer(chars) as Lexer; + return lexer; + } + public createParserFromLexer(lexer: Lexer): any { + const tokenStream = new CommonTokenStream(lexer); + return new PostgreSQLParser(tokenStream); + } +} diff --git a/tsconfig.json b/tsconfig.json index f42337b..507a25f 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -3,7 +3,7 @@ "outDir": "./dist/", "sourceMap": true, "allowJs":true, - "target": "es6", + "target": "es5", "module": "commonjs", "declaration": true, "noUnusedLocals": true, diff --git a/yarn.lock b/yarn.lock index c6429e9..0928162 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2,151 +2,170 @@ # yarn lockfile v1 -"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.10.4": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.10.4.tgz#168da1a36e90da68ae8d49c0f1b48c7c6249213a" - integrity sha512-vG6SvB6oYEhvgisZNFRmRCUkLz11c7rp+tbNTynGqc6mS1d5ATd/sGyV6W0KZZnXRKMTzZDRgQT3Ou9jhpAfUg== +"@ampproject/remapping@^2.1.0": + version "2.2.0" + resolved "https://registry.yarnpkg.com/@ampproject/remapping/-/remapping-2.2.0.tgz#56c133824780de3174aed5ab6834f3026790154d" + integrity sha512-qRmjj8nj9qmLTQXXmaR1cck3UXSRMPrbsLJAasZpF+t3riI71BXed5ebIOYwQntykeZuhjsdweEc9BxH5Jc26w== + dependencies: + "@jridgewell/gen-mapping" "^0.1.0" + "@jridgewell/trace-mapping" "^0.3.9" + +"@babel/code-frame@7.12.11": + version "7.12.11" + resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.12.11.tgz#f4ad435aa263db935b8f10f2c552d23fb716a63f" + integrity sha512-Zt1yodBx1UcyiePMSkWnU4hPqhwq7hGi2nFL1LeA3EUl+q2LQx16MISgJ0+z7dnmgvP9QtIleuETGOiOH1RcIw== dependencies: "@babel/highlight" "^7.10.4" -"@babel/core@^7.1.0": - version "7.11.4" - resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.11.4.tgz#4301dfdfafa01eeb97f1896c5501a3f0655d4229" - integrity sha512-5deljj5HlqRXN+5oJTY7Zs37iH3z3b++KjiKtIsJy1NrjOOVSEaJHEetLBhyu0aQOSNNZ/0IuEAan9GzRuDXHg== +"@babel/code-frame@^7.0.0", "@babel/code-frame@^7.18.6": + version "7.18.6" + resolved "https://registry.yarnpkg.com/@babel/code-frame/-/code-frame-7.18.6.tgz#3b25d38c89600baa2dcc219edfa88a74eb2c427a" + integrity sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q== dependencies: - "@babel/code-frame" "^7.10.4" - "@babel/generator" "^7.11.4" - "@babel/helper-module-transforms" "^7.11.0" - "@babel/helpers" "^7.10.4" - "@babel/parser" "^7.11.4" - "@babel/template" "^7.10.4" - "@babel/traverse" "^7.11.0" - "@babel/types" "^7.11.0" + "@babel/highlight" "^7.18.6" + +"@babel/compat-data@^7.20.0": + version "7.20.5" + resolved "https://registry.yarnpkg.com/@babel/compat-data/-/compat-data-7.20.5.tgz#86f172690b093373a933223b4745deeb6049e733" + integrity sha512-KZXo2t10+/jxmkhNXc7pZTqRvSOIvVv/+lJwHS+B2rErwOyjuVRh60yVpb7liQ1U5t7lLJ1bz+t8tSypUZdm0g== + +"@babel/core@^7.1.0": + version "7.20.5" + resolved "https://registry.yarnpkg.com/@babel/core/-/core-7.20.5.tgz#45e2114dc6cd4ab167f81daf7820e8fa1250d113" + integrity sha512-UdOWmk4pNWTm/4DlPUl/Pt4Gz4rcEMb7CY0Y3eJl5Yz1vI8ZJGmHWaVE55LoxRjdpx0z259GE9U5STA9atUinQ== + dependencies: + "@ampproject/remapping" "^2.1.0" + "@babel/code-frame" "^7.18.6" + "@babel/generator" "^7.20.5" + "@babel/helper-compilation-targets" "^7.20.0" + "@babel/helper-module-transforms" "^7.20.2" + "@babel/helpers" "^7.20.5" + "@babel/parser" "^7.20.5" + "@babel/template" "^7.18.10" + "@babel/traverse" "^7.20.5" + "@babel/types" "^7.20.5" convert-source-map "^1.7.0" debug "^4.1.0" - gensync "^1.0.0-beta.1" - json5 "^2.1.2" - lodash "^4.17.19" - resolve "^1.3.2" - semver "^5.4.1" - source-map "^0.5.0" + gensync "^1.0.0-beta.2" + json5 "^2.2.1" + semver "^6.3.0" -"@babel/generator@^7.11.0", "@babel/generator@^7.11.4", "@babel/generator@^7.4.0": - version "7.11.4" - resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.11.4.tgz#1ec7eec00defba5d6f83e50e3ee72ae2fee482be" - integrity sha512-Rn26vueFx0eOoz7iifCN2UHT6rGtnkSGWSoDRIy8jZN3B91PzeSULbswfLoOWuTuAcNwpG/mxy+uCTDnZ9Mp1g== +"@babel/generator@^7.20.5", "@babel/generator@^7.4.0": + version "7.20.5" + resolved "https://registry.yarnpkg.com/@babel/generator/-/generator-7.20.5.tgz#cb25abee3178adf58d6814b68517c62bdbfdda95" + integrity sha512-jl7JY2Ykn9S0yj4DQP82sYvPU+T3g0HFcWTqDLqiuA9tGRNIj9VfbtXGAYTTkyNEnQk1jkMGOdYka8aG/lulCA== dependencies: - "@babel/types" "^7.11.0" + "@babel/types" "^7.20.5" + "@jridgewell/gen-mapping" "^0.3.2" jsesc "^2.5.1" - source-map "^0.5.0" -"@babel/helper-function-name@^7.10.4": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.10.4.tgz#d2d3b20c59ad8c47112fa7d2a94bc09d5ef82f1a" - integrity sha512-YdaSyz1n8gY44EmN7x44zBn9zQ1Ry2Y+3GTA+3vH6Mizke1Vw0aWDM66FOYEPw8//qKkmqOckrGgTYa+6sceqQ== +"@babel/helper-compilation-targets@^7.20.0": + version "7.20.0" + resolved "https://registry.yarnpkg.com/@babel/helper-compilation-targets/-/helper-compilation-targets-7.20.0.tgz#6bf5374d424e1b3922822f1d9bdaa43b1a139d0a" + integrity sha512-0jp//vDGp9e8hZzBc6N/KwA5ZK3Wsm/pfm4CrY7vzegkVxc65SgSn6wYOnwHe9Js9HRQ1YTCKLGPzDtaS3RoLQ== dependencies: - "@babel/helper-get-function-arity" "^7.10.4" - "@babel/template" "^7.10.4" - "@babel/types" "^7.10.4" + "@babel/compat-data" "^7.20.0" + "@babel/helper-validator-option" "^7.18.6" + browserslist "^4.21.3" + semver "^6.3.0" -"@babel/helper-get-function-arity@^7.10.4": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/helper-get-function-arity/-/helper-get-function-arity-7.10.4.tgz#98c1cbea0e2332f33f9a4661b8ce1505b2c19ba2" - integrity sha512-EkN3YDB+SRDgiIUnNgcmiD361ti+AVbL3f3Henf6dqqUyr5dMsorno0lJWJuLhDhkI5sYEpgj6y9kB8AOU1I2A== - dependencies: - "@babel/types" "^7.10.4" +"@babel/helper-environment-visitor@^7.18.9": + version "7.18.9" + resolved "https://registry.yarnpkg.com/@babel/helper-environment-visitor/-/helper-environment-visitor-7.18.9.tgz#0c0cee9b35d2ca190478756865bb3528422f51be" + integrity sha512-3r/aACDJ3fhQ/EVgFy0hpj8oHyHpQc+LPtJoY9SzTThAsStm4Ptegq92vqKoE3vD706ZVFWITnMnxucw+S9Ipg== -"@babel/helper-member-expression-to-functions@^7.10.4": - version "7.11.0" - resolved "https://registry.yarnpkg.com/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.11.0.tgz#ae69c83d84ee82f4b42f96e2a09410935a8f26df" - integrity sha512-JbFlKHFntRV5qKw3YC0CvQnDZ4XMwgzzBbld7Ly4Mj4cbFy3KywcR8NtNctRToMWJOVvLINJv525Gd6wwVEx/Q== +"@babel/helper-function-name@^7.19.0": + version "7.19.0" + resolved "https://registry.yarnpkg.com/@babel/helper-function-name/-/helper-function-name-7.19.0.tgz#941574ed5390682e872e52d3f38ce9d1bef4648c" + integrity sha512-WAwHBINyrpqywkUH0nTnNgI5ina5TFn85HKS0pbPDfxFfhyR/aNQEn4hGi1P1JyT//I0t4OgXUlofzWILRvS5w== dependencies: - "@babel/types" "^7.11.0" + "@babel/template" "^7.18.10" + "@babel/types" "^7.19.0" -"@babel/helper-module-imports@^7.10.4": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.10.4.tgz#4c5c54be04bd31670a7382797d75b9fa2e5b5620" - integrity sha512-nEQJHqYavI217oD9+s5MUBzk6x1IlvoS9WTPfgG43CbMEeStE0v+r+TucWdx8KFGowPGvyOkDT9+7DHedIDnVw== +"@babel/helper-hoist-variables@^7.18.6": + version "7.18.6" + resolved "https://registry.yarnpkg.com/@babel/helper-hoist-variables/-/helper-hoist-variables-7.18.6.tgz#d4d2c8fb4baeaa5c68b99cc8245c56554f926678" + integrity sha512-UlJQPkFqFULIcyW5sbzgbkxn2FKRgwWiRexcuaR8RNJRy8+LLveqPjwZV/bwrLZCN0eUHD/x8D0heK1ozuoo6Q== dependencies: - "@babel/types" "^7.10.4" + "@babel/types" "^7.18.6" -"@babel/helper-module-transforms@^7.11.0": - version "7.11.0" - resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.11.0.tgz#b16f250229e47211abdd84b34b64737c2ab2d359" - integrity sha512-02EVu8COMuTRO1TAzdMtpBPbe6aQ1w/8fePD2YgQmxZU4gpNWaL9gK3Jp7dxlkUlUCJOTaSeA+Hrm1BRQwqIhg== +"@babel/helper-module-imports@^7.18.6": + version "7.18.6" + resolved "https://registry.yarnpkg.com/@babel/helper-module-imports/-/helper-module-imports-7.18.6.tgz#1e3ebdbbd08aad1437b428c50204db13c5a3ca6e" + integrity sha512-0NFvs3VkuSYbFi1x2Vd6tKrywq+z/cLeYC/RJNFrIX/30Bf5aiGYbtvGXolEktzJH8o5E5KJ3tT+nkxuuZFVlA== dependencies: - "@babel/helper-module-imports" "^7.10.4" - "@babel/helper-replace-supers" "^7.10.4" - "@babel/helper-simple-access" "^7.10.4" - "@babel/helper-split-export-declaration" "^7.11.0" - "@babel/template" "^7.10.4" - "@babel/types" "^7.11.0" - lodash "^4.17.19" + "@babel/types" "^7.18.6" -"@babel/helper-optimise-call-expression@^7.10.4": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.10.4.tgz#50dc96413d594f995a77905905b05893cd779673" - integrity sha512-n3UGKY4VXwXThEiKrgRAoVPBMqeoPgHVqiHZOanAJCG9nQUL2pLRQirUzl0ioKclHGpGqRgIOkgcIJaIWLpygg== +"@babel/helper-module-transforms@^7.20.2": + version "7.20.2" + resolved "https://registry.yarnpkg.com/@babel/helper-module-transforms/-/helper-module-transforms-7.20.2.tgz#ac53da669501edd37e658602a21ba14c08748712" + integrity sha512-zvBKyJXRbmK07XhMuujYoJ48B5yvvmM6+wcpv6Ivj4Yg6qO7NOZOSnvZN9CRl1zz1Z4cKf8YejmCMh8clOoOeA== dependencies: - "@babel/types" "^7.10.4" + "@babel/helper-environment-visitor" "^7.18.9" + "@babel/helper-module-imports" "^7.18.6" + "@babel/helper-simple-access" "^7.20.2" + "@babel/helper-split-export-declaration" "^7.18.6" + "@babel/helper-validator-identifier" "^7.19.1" + "@babel/template" "^7.18.10" + "@babel/traverse" "^7.20.1" + "@babel/types" "^7.20.2" "@babel/helper-plugin-utils@^7.0.0", "@babel/helper-plugin-utils@^7.8.0": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.10.4.tgz#2f75a831269d4f677de49986dff59927533cf375" - integrity sha512-O4KCvQA6lLiMU9l2eawBPMf1xPP8xPfB3iEQw150hOVTqj/rfXz0ThTb4HEzqQfs2Bmo5Ay8BzxfzVtBrr9dVg== + version "7.20.2" + resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.20.2.tgz#d1b9000752b18d0877cff85a5c376ce5c3121629" + integrity sha512-8RvlJG2mj4huQ4pZ+rU9lqKi9ZKiRmuvGuM2HlWmkmgOhbs6zEAw6IEiJ5cQqGbDzGZOhwuOQNtZMi/ENLjZoQ== -"@babel/helper-replace-supers@^7.10.4": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/helper-replace-supers/-/helper-replace-supers-7.10.4.tgz#d585cd9388ea06e6031e4cd44b6713cbead9e6cf" - integrity sha512-sPxZfFXocEymYTdVK1UNmFPBN+Hv5mJkLPsYWwGBxZAxaWfFu+xqp7b6qWD0yjNuNL2VKc6L5M18tOXUP7NU0A== +"@babel/helper-simple-access@^7.20.2": + version "7.20.2" + resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.20.2.tgz#0ab452687fe0c2cfb1e2b9e0015de07fc2d62dd9" + integrity sha512-+0woI/WPq59IrqDYbVGfshjT5Dmk/nnbdpcF8SnMhhXObpTq2KNBdLFRFrkVdbDOyUmHBCxzm5FHV1rACIkIbA== dependencies: - "@babel/helper-member-expression-to-functions" "^7.10.4" - "@babel/helper-optimise-call-expression" "^7.10.4" - "@babel/traverse" "^7.10.4" - "@babel/types" "^7.10.4" + "@babel/types" "^7.20.2" -"@babel/helper-simple-access@^7.10.4": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/helper-simple-access/-/helper-simple-access-7.10.4.tgz#0f5ccda2945277a2a7a2d3a821e15395edcf3461" - integrity sha512-0fMy72ej/VEvF8ULmX6yb5MtHG4uH4Dbd6I/aHDb/JVg0bbivwt9Wg+h3uMvX+QSFtwr5MeItvazbrc4jtRAXw== +"@babel/helper-split-export-declaration@^7.18.6": + version "7.18.6" + resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.18.6.tgz#7367949bc75b20c6d5a5d4a97bba2824ae8ef075" + integrity sha512-bde1etTx6ZyTmobl9LLMMQsaizFVZrquTEHOqKeQESMKo4PlObf+8+JA25ZsIpZhT/WEd39+vOdLXAFG/nELpA== dependencies: - "@babel/template" "^7.10.4" - "@babel/types" "^7.10.4" + "@babel/types" "^7.18.6" -"@babel/helper-split-export-declaration@^7.11.0": - version "7.11.0" - resolved "https://registry.yarnpkg.com/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.11.0.tgz#f8a491244acf6a676158ac42072911ba83ad099f" - integrity sha512-74Vejvp6mHkGE+m+k5vHY93FX2cAtrw1zXrZXRlG4l410Nm9PxfEiVTn1PjDPV5SnmieiueY4AFg2xqhNFuuZg== +"@babel/helper-string-parser@^7.19.4": + version "7.19.4" + resolved "https://registry.yarnpkg.com/@babel/helper-string-parser/-/helper-string-parser-7.19.4.tgz#38d3acb654b4701a9b77fb0615a96f775c3a9e63" + integrity sha512-nHtDoQcuqFmwYNYPz3Rah5ph2p8PFeFCsZk9A/48dPc/rGocJ5J3hAAZ7pb76VWX3fZKu+uEr/FhH5jLx7umrw== + +"@babel/helper-validator-identifier@^7.18.6", "@babel/helper-validator-identifier@^7.19.1": + version "7.19.1" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz#7eea834cf32901ffdc1a7ee555e2f9c27e249ca2" + integrity sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w== + +"@babel/helper-validator-option@^7.18.6": + version "7.18.6" + resolved "https://registry.yarnpkg.com/@babel/helper-validator-option/-/helper-validator-option-7.18.6.tgz#bf0d2b5a509b1f336099e4ff36e1a63aa5db4db8" + integrity sha512-XO7gESt5ouv/LRJdrVjkShckw6STTaB7l9BrpBaAHDeF5YZT+01PCwmR0SJHnkW6i8OwW/EVWRShfi4j2x+KQw== + +"@babel/helpers@^7.20.5": + version "7.20.6" + resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.20.6.tgz#e64778046b70e04779dfbdf924e7ebb45992c763" + integrity sha512-Pf/OjgfgFRW5bApskEz5pvidpim7tEDPlFtKcNRXWmfHGn9IEI2W2flqRQXTFb7gIPTyK++N6rVHuwKut4XK6w== dependencies: - "@babel/types" "^7.11.0" + "@babel/template" "^7.18.10" + "@babel/traverse" "^7.20.5" + "@babel/types" "^7.20.5" -"@babel/helper-validator-identifier@^7.10.4": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/helper-validator-identifier/-/helper-validator-identifier-7.10.4.tgz#a78c7a7251e01f616512d31b10adcf52ada5e0d2" - integrity sha512-3U9y+43hz7ZM+rzG24Qe2mufW5KhvFg/NhnNph+i9mgCtdTCtMJuI1TMkrIUiK7Ix4PYlRF9I5dhqaLYA/ADXw== - -"@babel/helpers@^7.10.4": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/helpers/-/helpers-7.10.4.tgz#2abeb0d721aff7c0a97376b9e1f6f65d7a475044" - integrity sha512-L2gX/XeUONeEbI78dXSrJzGdz4GQ+ZTA/aazfUsFaWjSe95kiCuOZ5HsXvkiw3iwF+mFHSRUfJU8t6YavocdXA== +"@babel/highlight@^7.10.4", "@babel/highlight@^7.18.6": + version "7.18.6" + resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.18.6.tgz#81158601e93e2563795adcbfbdf5d64be3f2ecdf" + integrity sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g== dependencies: - "@babel/template" "^7.10.4" - "@babel/traverse" "^7.10.4" - "@babel/types" "^7.10.4" - -"@babel/highlight@^7.10.4": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/highlight/-/highlight-7.10.4.tgz#7d1bdfd65753538fabe6c38596cdb76d9ac60143" - integrity sha512-i6rgnR/YgPEQzZZnbTHHuZdlE8qyoBNalD6F+q4vAFlcMEcqmkoG+mPqJYJCo63qPf74+Y1UZsl3l6f7/RIkmA== - dependencies: - "@babel/helper-validator-identifier" "^7.10.4" + "@babel/helper-validator-identifier" "^7.18.6" chalk "^2.0.0" js-tokens "^4.0.0" -"@babel/parser@^7.1.0", "@babel/parser@^7.10.4", "@babel/parser@^7.11.0", "@babel/parser@^7.11.4", "@babel/parser@^7.4.3": - version "7.11.4" - resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.11.4.tgz#6fa1a118b8b0d80d0267b719213dc947e88cc0ca" - integrity sha512-MggwidiH+E9j5Sh8pbrX5sJvMcsqS5o+7iB42M9/k0CD63MjYbdP4nhSh7uB5wnv2/RVzTZFTxzF/kIa5mrCqA== +"@babel/parser@^7.1.0", "@babel/parser@^7.18.10", "@babel/parser@^7.20.5", "@babel/parser@^7.4.3": + version "7.20.5" + resolved "https://registry.yarnpkg.com/@babel/parser/-/parser-7.20.5.tgz#7f3c7335fe417665d929f34ae5dceae4c04015e8" + integrity sha512-r27t/cy/m9uKLXQNWWebeCUHgnAZq0CpG1OwKRxzJMP1vpSU4bSIK2hq+/cp0bQxetkXx38n09rNu8jVkcK/zA== "@babel/plugin-syntax-object-rest-spread@^7.0.0": version "7.8.3" @@ -155,37 +174,38 @@ dependencies: "@babel/helper-plugin-utils" "^7.8.0" -"@babel/template@^7.10.4", "@babel/template@^7.4.0": - version "7.10.4" - resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.10.4.tgz#3251996c4200ebc71d1a8fc405fba940f36ba278" - integrity sha512-ZCjD27cGJFUB6nmCB1Enki3r+L5kJveX9pq1SvAUKoICy6CZ9yD8xO086YXdYhvNjBdnekm4ZnaP5yC8Cs/1tA== +"@babel/template@^7.18.10", "@babel/template@^7.4.0": + version "7.18.10" + resolved "https://registry.yarnpkg.com/@babel/template/-/template-7.18.10.tgz#6f9134835970d1dbf0835c0d100c9f38de0c5e71" + integrity sha512-TI+rCtooWHr3QJ27kJxfjutghu44DLnasDMwpDqCXVTal9RLp3RSYNh4NdBrRP2cQAoG9A8juOQl6P6oZG4JxA== dependencies: - "@babel/code-frame" "^7.10.4" - "@babel/parser" "^7.10.4" - "@babel/types" "^7.10.4" + "@babel/code-frame" "^7.18.6" + "@babel/parser" "^7.18.10" + "@babel/types" "^7.18.10" -"@babel/traverse@^7.1.0", "@babel/traverse@^7.10.4", "@babel/traverse@^7.11.0", "@babel/traverse@^7.4.3": - version "7.11.0" - resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.11.0.tgz#9b996ce1b98f53f7c3e4175115605d56ed07dd24" - integrity sha512-ZB2V+LskoWKNpMq6E5UUCrjtDUh5IOTAyIl0dTjIEoXum/iKWkoIEKIRDnUucO6f+2FzNkE0oD4RLKoPIufDtg== +"@babel/traverse@^7.1.0", "@babel/traverse@^7.20.1", "@babel/traverse@^7.20.5", "@babel/traverse@^7.4.3": + version "7.20.5" + resolved "https://registry.yarnpkg.com/@babel/traverse/-/traverse-7.20.5.tgz#78eb244bea8270fdda1ef9af22a5d5e5b7e57133" + integrity sha512-WM5ZNN3JITQIq9tFZaw1ojLU3WgWdtkxnhM1AegMS+PvHjkM5IXjmYEGY7yukz5XS4sJyEf2VzWjI8uAavhxBQ== dependencies: - "@babel/code-frame" "^7.10.4" - "@babel/generator" "^7.11.0" - "@babel/helper-function-name" "^7.10.4" - "@babel/helper-split-export-declaration" "^7.11.0" - "@babel/parser" "^7.11.0" - "@babel/types" "^7.11.0" + "@babel/code-frame" "^7.18.6" + "@babel/generator" "^7.20.5" + "@babel/helper-environment-visitor" "^7.18.9" + "@babel/helper-function-name" "^7.19.0" + "@babel/helper-hoist-variables" "^7.18.6" + "@babel/helper-split-export-declaration" "^7.18.6" + "@babel/parser" "^7.20.5" + "@babel/types" "^7.20.5" debug "^4.1.0" globals "^11.1.0" - lodash "^4.17.19" -"@babel/types@^7.0.0", "@babel/types@^7.10.4", "@babel/types@^7.11.0", "@babel/types@^7.3.0", "@babel/types@^7.4.0": - version "7.11.0" - resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.11.0.tgz#2ae6bf1ba9ae8c3c43824e5861269871b206e90d" - integrity sha512-O53yME4ZZI0jO1EVGtF1ePGl0LHirG4P1ibcD80XyzZcKhcMFeCXmh4Xb1ifGBIV233Qg12x4rBfQgA+tmOukA== +"@babel/types@^7.0.0", "@babel/types@^7.18.10", "@babel/types@^7.18.6", "@babel/types@^7.19.0", "@babel/types@^7.20.2", "@babel/types@^7.20.5", "@babel/types@^7.3.0", "@babel/types@^7.4.0": + version "7.20.5" + resolved "https://registry.yarnpkg.com/@babel/types/-/types-7.20.5.tgz#e206ae370b5393d94dfd1d04cd687cace53efa84" + integrity sha512-c9fst/h2/dcF7H+MJKZ2T0KjEQ8hY/BNnDk/H3XY8C4Aw/eWQXWn/lWntHF9ooUBnGmEvbfGrTgLWc+um0YDUg== dependencies: - "@babel/helper-validator-identifier" "^7.10.4" - lodash "^4.17.19" + "@babel/helper-string-parser" "^7.19.4" + "@babel/helper-validator-identifier" "^7.19.1" to-fast-properties "^2.0.0" "@cnakazawa/watch@^1.0.3": @@ -196,6 +216,40 @@ exec-sh "^0.3.2" minimist "^1.2.0" +"@eslint/eslintrc@^0.4.3": + version "0.4.3" + resolved "https://registry.yarnpkg.com/@eslint/eslintrc/-/eslintrc-0.4.3.tgz#9e42981ef035beb3dd49add17acb96e8ff6f394c" + integrity sha512-J6KFFz5QCYUJq3pf0mjEcCJVERbzv71PUIDczuh9JkwGEzced6CO5ADLHB1rbf/+oPBtoPfMYNOpGDzCANlbXw== + dependencies: + ajv "^6.12.4" + debug "^4.1.1" + espree "^7.3.0" + globals "^13.9.0" + ignore "^4.0.6" + import-fresh "^3.2.1" + js-yaml "^3.13.1" + minimatch "^3.0.4" + strip-json-comments "^3.1.1" + +"@humanwhocodes/config-array@^0.5.0": + version "0.5.0" + resolved "https://registry.yarnpkg.com/@humanwhocodes/config-array/-/config-array-0.5.0.tgz#1407967d4c6eecd7388f83acf1eaf4d0c6e58ef9" + integrity sha512-FagtKFz74XrTl7y6HCzQpwDfXP0yhxe9lHLD1UZxjvZIcbyRz8zTFF/yYNfSfzU414eDwZ1SrO0Qvtyf+wFMQg== + dependencies: + "@humanwhocodes/object-schema" "^1.2.0" + debug "^4.1.1" + minimatch "^3.0.4" + +"@humanwhocodes/object-schema@^1.2.0": + version "1.2.1" + resolved "https://registry.yarnpkg.com/@humanwhocodes/object-schema/-/object-schema-1.2.1.tgz#b520529ec21d8e5945a1851dfd1c32e94e39ff45" + integrity sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA== + +"@hutson/parse-repository-url@^3.0.0": + version "3.0.2" + resolved "https://registry.yarnpkg.com/@hutson/parse-repository-url/-/parse-repository-url-3.0.2.tgz#98c23c950a3d9b6c8f0daed06da6c3af06981340" + integrity sha512-H9XAx3hc0BQHY6l+IFSWHDySypcXsvsuLhgYLUGywmJ5pswRVQJUHpOsobnLYp2ZUaUlKiKDrgWWhosOwAEM8Q== + "@jest/console@^24.7.1", "@jest/console@^24.9.0": version "24.9.0" resolved "https://registry.yarnpkg.com/@jest/console/-/console-24.9.0.tgz#79b1bc06fb74a8cfb01cbdedf945584b1b9707f0" @@ -344,15 +398,55 @@ "@types/istanbul-reports" "^1.1.1" "@types/yargs" "^13.0.0" +"@jridgewell/gen-mapping@^0.1.0": + version "0.1.1" + resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.1.1.tgz#e5d2e450306a9491e3bd77e323e38d7aff315996" + integrity sha512-sQXCasFk+U8lWYEe66WxRDOE9PjVz4vSM51fTu3Hw+ClTpUSQb718772vH3pyS5pShp6lvQM7SxgIDXXXmOX7w== + dependencies: + "@jridgewell/set-array" "^1.0.0" + "@jridgewell/sourcemap-codec" "^1.4.10" + +"@jridgewell/gen-mapping@^0.3.2": + version "0.3.2" + resolved "https://registry.yarnpkg.com/@jridgewell/gen-mapping/-/gen-mapping-0.3.2.tgz#c1aedc61e853f2bb9f5dfe6d4442d3b565b253b9" + integrity sha512-mh65xKQAzI6iBcFzwv28KVWSmCkdRBWoOh+bYQGW3+6OZvbbN3TqMGo5hqYxQniRcH9F2VZIoJCm4pa3BPDK/A== + dependencies: + "@jridgewell/set-array" "^1.0.1" + "@jridgewell/sourcemap-codec" "^1.4.10" + "@jridgewell/trace-mapping" "^0.3.9" + +"@jridgewell/resolve-uri@3.1.0": + version "3.1.0" + resolved "https://registry.yarnpkg.com/@jridgewell/resolve-uri/-/resolve-uri-3.1.0.tgz#2203b118c157721addfe69d47b70465463066d78" + integrity sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w== + +"@jridgewell/set-array@^1.0.0", "@jridgewell/set-array@^1.0.1": + version "1.1.2" + resolved "https://registry.yarnpkg.com/@jridgewell/set-array/-/set-array-1.1.2.tgz#7c6cf998d6d20b914c0a55a91ae928ff25965e72" + integrity sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw== + +"@jridgewell/sourcemap-codec@1.4.14", "@jridgewell/sourcemap-codec@^1.4.10": + version "1.4.14" + resolved "https://registry.yarnpkg.com/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.14.tgz#add4c98d341472a289190b424efbdb096991bb24" + integrity sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw== + +"@jridgewell/trace-mapping@^0.3.9": + version "0.3.17" + resolved "https://registry.yarnpkg.com/@jridgewell/trace-mapping/-/trace-mapping-0.3.17.tgz#793041277af9073b0951a7fe0f0d8c4c98c36985" + integrity sha512-MCNzAp77qzKca9+W/+I0+sEpaUnZoeasnghNeVc41VZCEKaCH73Vq3BZZ/SzWIgrqE4H4ceI+p+b6C0mHf9T4g== + dependencies: + "@jridgewell/resolve-uri" "3.1.0" + "@jridgewell/sourcemap-codec" "1.4.14" + "@types/antlr4@4.7.0": version "4.7.0" - resolved "http://registry.npm.dtstack.com/@types%2fantlr4/-/antlr4-4.7.0.tgz#e6300119bddff6e23f5bbd299f5cf3c722a6249b" - integrity sha1-5jABGb3f9uI/W70pn1zzxyKmJJs= + resolved "https://registry.yarnpkg.com/@types/antlr4/-/antlr4-4.7.0.tgz#e6300119bddff6e23f5bbd299f5cf3c722a6249b" + integrity sha512-WdyHH4PHxBQkeWoRTbuC/dvf0QErJpJE4UpESQSRmKoMER15DCLFHAHQjkwevMKQie0kqawS/eTY563GGMbz/g== "@types/babel__core@^7.1.0": - version "7.1.9" - resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.1.9.tgz#77e59d438522a6fb898fa43dc3455c6e72f3963d" - integrity sha512-sY2RsIJ5rpER1u3/aQ8OFSI7qGIy8o1NEEbgb2UaJcvOtXOMpd39ko723NBpjQFg9SIX7TXtjejZVGeIMLhoOw== + version "7.1.20" + resolved "https://registry.yarnpkg.com/@types/babel__core/-/babel__core-7.1.20.tgz#e168cdd612c92a2d335029ed62ac94c95b362359" + integrity sha512-PVb6Bg2QuscZ30FvOU7z4guG6c926D9YRvOxEaelzndpMsvP+YM74Q/dAFASpg2l6+XLalxSGxcq/lrgYWZtyQ== dependencies: "@babel/parser" "^7.1.0" "@babel/types" "^7.0.0" @@ -361,41 +455,36 @@ "@types/babel__traverse" "*" "@types/babel__generator@*": - version "7.6.1" - resolved "https://registry.yarnpkg.com/@types/babel__generator/-/babel__generator-7.6.1.tgz#4901767b397e8711aeb99df8d396d7ba7b7f0e04" - integrity sha512-bBKm+2VPJcMRVwNhxKu8W+5/zT7pwNEqeokFOmbvVSqGzFneNxYcEBro9Ac7/N9tlsaPYnZLK8J1LWKkMsLAew== + version "7.6.4" + resolved "https://registry.yarnpkg.com/@types/babel__generator/-/babel__generator-7.6.4.tgz#1f20ce4c5b1990b37900b63f050182d28c2439b7" + integrity sha512-tFkciB9j2K755yrTALxD44McOrk+gfpIpvC3sxHjRawj6PfnQxrse4Clq5y/Rq+G3mrBurMax/lG8Qn2t9mSsg== dependencies: "@babel/types" "^7.0.0" "@types/babel__template@*": - version "7.0.2" - resolved "https://registry.yarnpkg.com/@types/babel__template/-/babel__template-7.0.2.tgz#4ff63d6b52eddac1de7b975a5223ed32ecea9307" - integrity sha512-/K6zCpeW7Imzgab2bLkLEbz0+1JlFSrUMdw7KoIIu+IUdu51GWaBZpd3y1VXGVXzynvGa4DaIaxNZHiON3GXUg== + version "7.4.1" + resolved "https://registry.yarnpkg.com/@types/babel__template/-/babel__template-7.4.1.tgz#3d1a48fd9d6c0edfd56f2ff578daed48f36c8969" + integrity sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g== dependencies: "@babel/parser" "^7.1.0" "@babel/types" "^7.0.0" "@types/babel__traverse@*", "@types/babel__traverse@^7.0.6": - version "7.0.13" - resolved "https://registry.yarnpkg.com/@types/babel__traverse/-/babel__traverse-7.0.13.tgz#1874914be974a492e1b4cb00585cabb274e8ba18" - integrity sha512-i+zS7t6/s9cdQvbqKDARrcbrPvtJGlbYsMkazo03nTAK3RX9FNrLllXys22uiTGJapPOTZTQ35nHh4ISph4SLQ== + version "7.18.3" + resolved "https://registry.yarnpkg.com/@types/babel__traverse/-/babel__traverse-7.18.3.tgz#dfc508a85781e5698d5b33443416b6268c4b3e8d" + integrity sha512-1kbcJ40lLB7MHsj39U4Sh1uTd2E7rLEa79kmDpI6cy+XiXsteB3POdQomoq4FxszMrO3ZYchkhYJw7A2862b3w== dependencies: "@babel/types" "^7.3.0" -"@types/color-name@^1.1.1": - version "1.1.1" - resolved "https://registry.yarnpkg.com/@types/color-name/-/color-name-1.1.1.tgz#1c1261bbeaa10a8055bbc5d8ab84b7b2afc846a0" - integrity sha512-rr+OQyAjxze7GgWrSaJwydHStIhHq2lvY3BOC2Mj7KnzI7XK0Uw1TOOdI9lDoajEbSWLiYgoo4f1R51erQfhPQ== - "@types/eslint-visitor-keys@^1.0.0": version "1.0.0" resolved "https://registry.yarnpkg.com/@types/eslint-visitor-keys/-/eslint-visitor-keys-1.0.0.tgz#1ee30d79544ca84d68d4b3cdb0af4f205663dd2d" integrity sha512-OCutwjDZ4aFS6PB1UZ988C4YgwlBHJd6wCeQqaLdmadZ/7e+w79+hbMUFC1QXDNCmdyoRfAFdm0RypzwR+Qpag== "@types/istanbul-lib-coverage@*", "@types/istanbul-lib-coverage@^2.0.0": - version "2.0.3" - resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.3.tgz#4ba8ddb720221f432e443bd5f9117fd22cfd4762" - integrity sha512-sz7iLqvVUg1gIedBOvlkxPlc8/uVzyS5OwGz1cKjXzkl3FpL3al0crU8YGU1WoHkxn0Wxbw5tyi6hvzJKNzFsw== + version "2.0.4" + resolved "https://registry.yarnpkg.com/@types/istanbul-lib-coverage/-/istanbul-lib-coverage-2.0.4.tgz#8467d4b3c087805d63580480890791277ce35c44" + integrity sha512-z/QT1XN4K4KYuslS23k62yDIDLwLFkzxOuMplDtObz0+y7VqJCaO2o+SPwHCvLFZh7xazvvoor2tA/hPz9ee7g== "@types/istanbul-lib-report@*": version "3.0.0" @@ -420,19 +509,19 @@ jest-diff "^24.3.0" "@types/json-schema@^7.0.3": - version "7.0.5" - resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.5.tgz#dcce4430e64b443ba8945f0290fb564ad5bac6dd" - integrity sha512-7+2BITlgjgDhH0vvwZU/HZJVyk+2XUlvxXe8dFMedNX/aMkaOq++rMAFXc0tM7ij15QaWlbdQASBR9dihi+bDQ== + version "7.0.11" + resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.11.tgz#d421b6c527a3037f7c84433fd2c4229e016863d3" + integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ== "@types/minimist@^1.2.0": - version "1.2.1" - resolved "http://registry.npm.dtstack.com/@types%2fminimist/-/minimist-1.2.1.tgz#283f669ff76d7b8260df8ab7a4262cc83d988256" - integrity sha1-KD9mn/dte4Jg34q3pCYsyD2YglY= + version "1.2.2" + resolved "https://registry.yarnpkg.com/@types/minimist/-/minimist-1.2.2.tgz#ee771e2ba4b3dc5b372935d549fd9617bf345b8c" + integrity sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ== "@types/normalize-package-data@^2.4.0": - version "2.4.0" - resolved "http://registry.npm.dtstack.com/@types%2fnormalize-package-data/-/normalize-package-data-2.4.0.tgz#e486d0d97396d79beedd0a6e33f4534ff6b4973e" - integrity sha1-5IbQ2XOW15vu3QpuM/RTT/a0lz4= + version "2.4.1" + resolved "https://registry.yarnpkg.com/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz#d3357479a0fdfdd5907fe67e17e0a85c906e1301" + integrity sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw== "@types/stack-utils@^1.0.1": version "1.0.1" @@ -440,14 +529,14 @@ integrity sha512-l42BggppR6zLmpfU6fq9HEa2oGPEI8yrSPL3GITjfRInppYFahObbIQOQK3UGxEnyQpltZLaPe75046NOZQikw== "@types/yargs-parser@*": - version "15.0.0" - resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-15.0.0.tgz#cb3f9f741869e20cce330ffbeb9271590483882d" - integrity sha512-FA/BWv8t8ZWJ+gEOnLLd8ygxH/2UFbAvgEonyfN6yWGLKc7zVjbpl2Y4CTjid9h2RfgPP6SEt6uHwEOply00yw== + version "21.0.0" + resolved "https://registry.yarnpkg.com/@types/yargs-parser/-/yargs-parser-21.0.0.tgz#0c60e537fa790f5f9472ed2776c2b71ec117351b" + integrity sha512-iO9ZQHkZxHn4mSakYV0vFHAVDyEOIJQrV2uZ06HxEPcx+mt8swXoZHIbaaJ2crJYFfErySgktuTZ3BeLz+XmFA== "@types/yargs@^13.0.0": - version "13.0.10" - resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-13.0.10.tgz#e77bf3fc73c781d48c2eb541f87c453e321e5f4b" - integrity sha512-MU10TSgzNABgdzKvQVW1nuuT+sgBMWeXNc3XOs5YXV5SDAK+PPja2eUuBNB9iqElu03xyEDqlnGw0jgl4nbqGQ== + version "13.0.12" + resolved "https://registry.yarnpkg.com/@types/yargs/-/yargs-13.0.12.tgz#d895a88c703b78af0465a9de88aa92c61430b092" + integrity sha512-qCxJE1qgz2y0hA4pIxjBR+PelCH0U5CK1XJXFwCNqfmliatKp47UCXXE9Dyk1OXBDLvsCF57TqQEJaeLfDYEOQ== dependencies: "@types/yargs-parser" "*" @@ -513,16 +602,16 @@ JSONStream@^1.0.4: version "1.3.5" - resolved "http://registry.npm.dtstack.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0" - integrity sha1-MgjB8I06TZkmGrZPkjArwV4RHKA= + resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0" + integrity sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ== dependencies: jsonparse "^1.2.0" through ">=2.2.7 <3" abab@^2.0.0: - version "2.0.4" - resolved "https://registry.yarnpkg.com/abab/-/abab-2.0.4.tgz#6dfa57b417ca06d21b2478f0e638302f99c2405c" - integrity sha512-Eu9ELJWCz/c1e9gTiCY+FceWxcqzjYEbqMgtndnuSqZSUCOL73TWNK2mHfIj4Cw2E/ongOp+JISVNCmovt2KYQ== + version "2.0.6" + resolved "https://registry.yarnpkg.com/abab/-/abab-2.0.6.tgz#41b80f2c871d19686216b82309231cfd3cb3d291" + integrity sha512-j2afSsaIENvHZN2B8GOpF566vZ5WVk5opAiMTvWgaQT8DkbOqsTfvNAvHoRGU2zzP8cPoqys+xHTRDWW8L+/BA== acorn-globals@^4.1.0: version "4.3.4" @@ -532,10 +621,10 @@ acorn-globals@^4.1.0: acorn "^6.0.1" acorn-walk "^6.0.1" -acorn-jsx@^5.2.0: - version "5.2.0" - resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.2.0.tgz#4c66069173d6fdd68ed85239fc256226182b2ebe" - integrity sha512-HiUX/+K2YpkpJ+SzBffkM/AQ2YE03S0U1kjTLVpoJdhZMOWy8qvXVN9JdLqv2QsaQ6MPYQIuNmwD8zOiYUofLQ== +acorn-jsx@^5.3.1: + version "5.3.2" + resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-5.3.2.tgz#7ed5bb55908b3b2f1bc55c6af1653bada7f07937" + integrity sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ== acorn-walk@^6.0.1: version "6.2.0" @@ -548,34 +637,44 @@ acorn@^5.5.3: integrity sha512-1D++VG7BhrtvQpNbBzovKNc1FLGGEE/oGe7b9xJm/RFHMBeUaUGpluV9RLjZa47YFdPcDAenEYuq9pQPcMdLJg== acorn@^6.0.1: - version "6.4.1" - resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.1.tgz#531e58ba3f51b9dacb9a6646ca4debf5b14ca474" - integrity sha512-ZVA9k326Nwrj3Cj9jlh3wGFutC2ZornPNARZwsNYqQYgN0EsV2d53w5RN/co65Ohn4sUAUtb1rSUAOD6XN9idA== + version "6.4.2" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-6.4.2.tgz#35866fd710528e92de10cf06016498e47e39e1e6" + integrity sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ== acorn@^7.4.0: - version "7.4.0" - resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.0.tgz#e1ad486e6c54501634c6c397c5c121daa383607c" - integrity sha512-+G7P8jJmCHr+S+cLfQxygbWhXy+8YTVGzAkpEbcLo2mLoL7tij/VG41QSHACSf5QgYRhMZYHuNc6drJaO0Da+w== + version "7.4.1" + resolved "https://registry.yarnpkg.com/acorn/-/acorn-7.4.1.tgz#feaed255973d2e77555b83dbc08851a6c63520fa" + integrity sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A== add-stream@^1.0.0: version "1.0.0" - resolved "http://registry.npm.dtstack.com/add-stream/-/add-stream-1.0.0.tgz#6a7990437ca736d5e1288db92bd3266d5f5cb2aa" - integrity sha1-anmQQ3ynNtXhKI25K9MmbV9csqo= + resolved "https://registry.yarnpkg.com/add-stream/-/add-stream-1.0.0.tgz#6a7990437ca736d5e1288db92bd3266d5f5cb2aa" + integrity sha512-qQLMr+8o0WC4FZGQTcJiKBVC59JylcPSrTtk6usvmIDFUOCKegapy1VHQwRbFMOFyb/inzUVqHs+eMYKDM1YeQ== -ajv@^6.10.0, ajv@^6.10.2, ajv@^6.12.3: - version "6.12.4" - resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.4.tgz#0614facc4522127fa713445c6bfd3ebd376e2234" - integrity sha512-eienB2c9qVQs2KWexhkrdMLVDoIQCz5KSeLxwg9Lzk4DOfBtIK9PQwwufcsn1jjGuf9WZmqPMbGxOzfcuphJCQ== +ajv@^6.10.0, ajv@^6.12.3, ajv@^6.12.4: + version "6.12.6" + resolved "https://registry.yarnpkg.com/ajv/-/ajv-6.12.6.tgz#baf5a62e802b07d977034586f8c3baf5adf26df4" + integrity sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g== dependencies: fast-deep-equal "^3.1.1" fast-json-stable-stringify "^2.0.0" json-schema-traverse "^0.4.1" uri-js "^4.2.2" +ajv@^8.0.1: + version "8.11.2" + resolved "https://registry.yarnpkg.com/ajv/-/ajv-8.11.2.tgz#aecb20b50607acf2569b6382167b65a96008bb78" + integrity sha512-E4bfmKAhGiSTvMfL1Myyycaub+cUEU2/IvpylXkUu7CHBkBj1f/ikdzbD7YQ6FKUbixDxeYvB/xY4fvyroDlQg== + dependencies: + fast-deep-equal "^3.1.1" + json-schema-traverse "^1.0.0" + require-from-string "^2.0.2" + uri-js "^4.2.2" + ansi-colors@^4.1.1: - version "4.1.1" - resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.1.tgz#cbb9ae256bf750af1eab344f229aa27fe94ba348" - integrity sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA== + version "4.1.3" + resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.3.tgz#37611340eb2243e70cc604cad35d63270d48781b" + integrity sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw== ansi-escapes@^3.0.0: version "3.2.0" @@ -583,19 +682,19 @@ ansi-escapes@^3.0.0: integrity sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ== ansi-regex@^3.0.0: - version "3.0.0" - resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.0.tgz#ed0317c322064f79466c02966bddb605ab37d998" - integrity sha1-7QMXwyIGT3lGbAKWa922Bas32Zg= + version "3.0.1" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-3.0.1.tgz#123d6479e92ad45ad897d4054e3c7ca7db4944e1" + integrity sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw== ansi-regex@^4.0.0, ansi-regex@^4.1.0: - version "4.1.0" - resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-4.1.0.tgz#8b9f8f08cf1acb843756a839ca8c7e3168c51997" - integrity sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg== + version "4.1.1" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-4.1.1.tgz#164daac87ab2d6f6db3a29875e2d1766582dabed" + integrity sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g== -ansi-regex@^5.0.0: - version "5.0.0" - resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.0.tgz#388539f55179bf39339c81af30a654d69f87cb75" - integrity sha512-bY6fj56OUQ0hU1KjFNDQuJFezqKdrAyFdIevADiqrWHwSlbmBNMHp5ak2f40Pm8JTFyM2mqxkG6ngkHO11f/lg== +ansi-regex@^5.0.1: + version "5.0.1" + resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-5.0.1.tgz#082cb2c89c9fe8659a311a53bd6a4dc5301db304" + integrity sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ== ansi-styles@^3.2.0, ansi-styles@^3.2.1: version "3.2.1" @@ -604,24 +703,16 @@ ansi-styles@^3.2.0, ansi-styles@^3.2.1: dependencies: color-convert "^1.9.0" -ansi-styles@^4.0.0: +ansi-styles@^4.0.0, ansi-styles@^4.1.0: version "4.3.0" - resolved "http://registry.npm.dtstack.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" - integrity sha1-7dgDYornHATIWuegkG7a00tkiTc= + resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.3.0.tgz#edd803628ae71c04c85ae7a0906edad34b648937" + integrity sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg== dependencies: color-convert "^2.0.1" -ansi-styles@^4.1.0: - version "4.2.1" - resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.2.1.tgz#90ae75c424d008d2624c5bf29ead3177ebfcf359" - integrity sha512-9VGjrMsG1vePxcSweQsN20KY/c4zN0h9fLjqAbwbPfahM3t+NL+M9HC8xeXG2I8pX5NoamTGNuomEUFI7fcUjA== - dependencies: - "@types/color-name" "^1.1.1" - color-convert "^2.0.1" - antlr4@4.7.2: version "4.7.2" - resolved "http://registry.npm.dtstack.com/antlr4/-/antlr4-4.7.2.tgz#9d0b5987bb63660de658055ee9149141b4d9b462" + resolved "https://registry.yarnpkg.com/antlr4/-/antlr4-4.7.2.tgz#9d0b5987bb63660de658055ee9149141b4d9b462" integrity sha512-vZA1xYufXLe3LX+ja9rIVxjRmILb1x3k7KYZHltRbfJtXjJ1DlFIqt+CbPYmghx0EuzY9DajiDw+MdyEt1qAsQ== anymatch@^2.0.0: @@ -642,7 +733,7 @@ argparse@^1.0.7: arr-diff@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-4.0.0.tgz#d6461074febfec71e7e15235761a329a5dc7c520" - integrity sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA= + integrity sha512-YVIQ82gZPGBebQV/a8dar4AitzCQs0jjXwMPZllpXMaGjXPYVUawSxQrRsjhjupyVxEvbHgUmIhKVlND+j02kA== arr-flatten@^1.1.0: version "1.1.0" @@ -652,55 +743,66 @@ arr-flatten@^1.1.0: arr-union@^3.1.0: version "3.1.0" resolved "https://registry.yarnpkg.com/arr-union/-/arr-union-3.1.0.tgz#e39b09aea9def866a8f206e288af63919bae39c4" - integrity sha1-45sJrqne+Gao8gbiiK9jkZuuOcQ= + integrity sha512-sKpyeERZ02v1FeCZT8lrfJq5u6goHCtpTAzPwJYe7c8SPFOboNjNg1vz2L4VTn9T4PQxEx13TbXLmYUcS6Ug7Q== array-equal@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/array-equal/-/array-equal-1.0.0.tgz#8c2a5ef2472fd9ea742b04c77a75093ba2757c93" - integrity sha1-jCpe8kcv2ep0KwTHenUJO6J1fJM= - -array-find-index@^1.0.1: - version "1.0.2" - resolved "http://registry.npm.dtstack.com/array-find-index/-/array-find-index-1.0.2.tgz#df010aa1287e164bbda6f9723b0a96a1ec4187a1" - integrity sha1-3wEKoSh+Fku9pvlyOwqWoexBh6E= + integrity sha512-H3LU5RLiSsGXPhN+Nipar0iR0IofH+8r89G2y1tBKxQ/agagKyAjhkAFDRBfodP2caPrNKHpAWNIM/c9yeL7uA== array-ify@^1.0.0: version "1.0.0" - resolved "http://registry.npm.dtstack.com/array-ify/-/array-ify-1.0.0.tgz#9e528762b4a9066ad163a6962a364418e9626ece" - integrity sha1-nlKHYrSpBmrRY6aWKjZEGOlibs4= + resolved "https://registry.yarnpkg.com/array-ify/-/array-ify-1.0.0.tgz#9e528762b4a9066ad163a6962a364418e9626ece" + integrity sha512-c5AMf34bKdvPhQ7tBGhqkgKNUzMr4WUs+WDtC2ZUGOUncbxKMTvqxYctiseW3+L4bA8ec+GcZ6/A/FW4m8ukng== array-unique@^0.3.2: version "0.3.2" resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.3.2.tgz#a894b75d4bc4f6cd679ef3244a9fd8f46ae2d428" - integrity sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg= + integrity sha512-SleRWjh9JUud2wH1hPs9rZBZ33H6T9HOiL0uwGnGx9FpE6wKGyfWugmbkEOIs6qWrZhg0LWeLziLrEwQJhs5mQ== + +array.prototype.reduce@^1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/array.prototype.reduce/-/array.prototype.reduce-1.0.5.tgz#6b20b0daa9d9734dd6bc7ea66b5bbce395471eac" + integrity sha512-kDdugMl7id9COE8R7MHF5jWk7Dqt/fs4Pv+JXoICnYwqpjjjbUurz6w5fT5IG6brLdJhv6/VoHB0H7oyIBXd+Q== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" + es-array-method-boxes-properly "^1.0.0" + is-string "^1.0.7" arrify@^1.0.1: version "1.0.1" - resolved "http://registry.npm.dtstack.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d" - integrity sha1-iYUI2iIm84DfkEcoRWhJwVAaSw0= + resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d" + integrity sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA== asn1@~0.2.3: - version "0.2.4" - resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.4.tgz#8d2475dfab553bb33e77b54e59e880bb8ce23136" - integrity sha512-jxwzQpLQjSmWXgwaCZE9Nz+glAG01yF1QnWgbhGwHI5A6FRIEY6IVqtHhIepHqI7/kyEyQEagBC5mBEFlIYvdg== + version "0.2.6" + resolved "https://registry.yarnpkg.com/asn1/-/asn1-0.2.6.tgz#0d3a7bb6e64e02a90c0303b31f292868ea09a08d" + integrity sha512-ix/FxPn0MDjeyJ7i/yoHGFt/EX6LyNbxSEhPPXODPL+KB0VPk86UYfL0lMdy+KCnv+fmvIzySwaK5COwqVbWTQ== dependencies: safer-buffer "~2.1.0" assert-plus@1.0.0, assert-plus@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/assert-plus/-/assert-plus-1.0.0.tgz#f12e0f3c5d77b0b1cdd9146942e4e96c1e4dd525" - integrity sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU= + integrity sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw== assign-symbols@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/assign-symbols/-/assign-symbols-1.0.0.tgz#59667f41fadd4f20ccbc2bb96b8d4f7f78ec0367" - integrity sha1-WWZ/QfrdTyDMvCu5a41Pf3jsA2c= + integrity sha512-Q+JC7Whu8HhmTdBph/Tq59IoRtoy6KAm5zzPv00WdujX82lbAL8K7WVjne7vdCsAmbF4AYaDOPyO3k0kl8qIrw== astral-regex@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-1.0.0.tgz#6c8c3fb827dd43ee3918f27b82782ab7658a6fd9" integrity sha512-+Ryf6g3BKoRc7jfp7ad8tM4TtMiaWvbF/1/sQcZPkkS7ag3D5nMBCe2UfOTONtAkaG0tO0ij3C5Lwmf1EiyjHg== +astral-regex@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/astral-regex/-/astral-regex-2.0.0.tgz#483143c567aeed4785759c0865786dc77d7d2e31" + integrity sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ== + async-limiter@~1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/async-limiter/-/async-limiter-1.0.1.tgz#dd379e94f0db8310b08291f9d64c3209766617fd" @@ -709,7 +811,7 @@ async-limiter@~1.0.0: asynckit@^0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/asynckit/-/asynckit-0.4.0.tgz#c79ed97f7f34cb8f2ba1bc9790bcc366474b4b79" - integrity sha1-x57Zf380y48robyXkLzDZkdLS3k= + integrity sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q== atob@^2.1.2: version "2.1.2" @@ -719,12 +821,12 @@ atob@^2.1.2: aws-sign2@~0.7.0: version "0.7.0" resolved "https://registry.yarnpkg.com/aws-sign2/-/aws-sign2-0.7.0.tgz#b46e890934a9591f2d2f6f86d7e6a9f1b3fe76a8" - integrity sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg= + integrity sha512-08kcGqnYf/YmjoRhfxyu+CLxBjUtHLXLXX/vUfx9l2LYzG3c1m61nrpyFUZI6zeS+Li/wWMMidD9KgrqtGq3mA== aws4@^1.8.0: - version "1.10.1" - resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.10.1.tgz#e1e82e4f3e999e2cfd61b161280d16a111f86428" - integrity sha512-zg7Hz2k5lI8kb7U32998pRRFin7zJlkfezGJjUc2heaD4Pw2wObakCDVzkKztTm/Ln7eiVvYsjqak0Ed4LkMDA== + version "1.11.0" + resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.11.0.tgz#d61f46d83b2519250e2784daf5b09479a8b41c59" + integrity sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA== babel-jest@^24.9.0: version "24.9.0" @@ -765,9 +867,9 @@ babel-preset-jest@^24.9.0: babel-plugin-jest-hoist "^24.9.0" balanced-match@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767" - integrity sha1-ibTRmasr7kneFk6gK4nORi1xt2c= + version "1.0.2" + resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.2.tgz#e83e3a7e3f300b34cb9d87f615fa0cbf357690ee" + integrity sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw== base@^0.11.1: version "0.11.2" @@ -785,7 +887,7 @@ base@^0.11.1: bcrypt-pbkdf@^1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.2.tgz#a4301d389b6a43f9b67ff3ca11a3f6637e360e9e" - integrity sha1-pDAdOJtqQ/m2f/PKEaP2Y342Dp4= + integrity sha512-qeFIXtP4MSoi6NLqO12WfqARWWuCKi2Rn/9hJLEmtB5yTNr9DqFWkJRCf2qShWzPeAMRnOgCrq0sg/KLv5ES9w== dependencies: tweetnacl "^0.14.3" @@ -832,6 +934,16 @@ browser-resolve@^1.11.3: dependencies: resolve "1.1.7" +browserslist@^4.21.3: + version "4.21.4" + resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.21.4.tgz#e7496bbc67b9e39dd0f98565feccdcb0d4ff6987" + integrity sha512-CBHJJdDmgjl3daYjN5Cp5kbTf1mUhZoS+beLklHIvkOWscs83YAhLlF3Wsh/lciQYAcbBJgTOD44VtG31ZM4Hw== + dependencies: + caniuse-lite "^1.0.30001400" + electron-to-chromium "^1.4.251" + node-releases "^2.0.6" + update-browserslist-db "^1.0.9" + bs-logger@0.x: version "0.2.6" resolved "https://registry.yarnpkg.com/bs-logger/-/bs-logger-0.2.6.tgz#eb7d365307a72cf974cc6cda76b68354ad336bd8" @@ -847,9 +959,9 @@ bser@2.1.1: node-int64 "^0.4.0" buffer-from@1.x, buffer-from@^1.0.0: - version "1.1.1" - resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef" - integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A== + version "1.1.2" + resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5" + integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ== cache-base@^1.0.1: version "1.0.1" @@ -866,52 +978,43 @@ cache-base@^1.0.1: union-value "^1.0.0" unset-value "^1.0.0" +call-bind@^1.0.0, call-bind@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/call-bind/-/call-bind-1.0.2.tgz#b1d4e89e688119c3c9a903ad30abb2f6a919be3c" + integrity sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA== + dependencies: + function-bind "^1.1.1" + get-intrinsic "^1.0.2" + callsites@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/callsites/-/callsites-3.1.0.tgz#b3630abd8943432f54b3f0519238e33cd7df2f73" integrity sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ== -camelcase-keys@^2.0.0: - version "2.1.0" - resolved "http://registry.npm.dtstack.com/camelcase-keys/-/camelcase-keys-2.1.0.tgz#308beeaffdf28119051efa1d932213c91b8f92e7" - integrity sha1-MIvur/3ygRkFHvodkyITyRuPkuc= - dependencies: - camelcase "^2.0.0" - map-obj "^1.0.0" - -camelcase-keys@^4.0.0: - version "4.2.0" - resolved "http://registry.npm.dtstack.com/camelcase-keys/-/camelcase-keys-4.2.0.tgz#a2aa5fb1af688758259c32c141426d78923b9b77" - integrity sha1-oqpfsa9oh1glnDLBQUJteJI7m3c= - dependencies: - camelcase "^4.1.0" - map-obj "^2.0.0" - quick-lru "^1.0.0" - camelcase-keys@^6.2.2: version "6.2.2" - resolved "http://registry.npm.dtstack.com/camelcase-keys/-/camelcase-keys-6.2.2.tgz#5e755d6ba51aa223ec7d3d52f25778210f9dc3c0" - integrity sha1-XnVda6UaoiPsfT1S8ld4IQ+dw8A= + resolved "https://registry.yarnpkg.com/camelcase-keys/-/camelcase-keys-6.2.2.tgz#5e755d6ba51aa223ec7d3d52f25778210f9dc3c0" + integrity sha512-YrwaA0vEKazPBkn0ipTiMpSajYDSe+KjQfrjhcBMxJt/znbvlHd8Pw/Vamaz5EB4Wfhs3SUR3Z9mwRu/P3s3Yg== dependencies: camelcase "^5.3.1" map-obj "^4.0.0" quick-lru "^4.0.1" -camelcase@^2.0.0: - version "2.1.1" - resolved "http://registry.npm.dtstack.com/camelcase/-/camelcase-2.1.1.tgz#7c1d16d679a1bbe59ca02cacecfb011e201f5a1f" - integrity sha1-fB0W1nmhu+WcoCys7PsBHiAfWh8= - camelcase@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-4.1.0.tgz#d545635be1e33c542649c69173e5de6acfae34dd" - integrity sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0= + integrity sha512-FxAv7HpHrXbh3aPo4o2qxHay2lkLY3x5Mw3KeE4KQE8ysVfziWeRZDwcjauvwBSGEC/nXUPzZy8zeh4HokqOnw== camelcase@^5.0.0, camelcase@^5.3.1: version "5.3.1" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-5.3.1.tgz#e3c9b31569e106811df242f715725a1f4c494320" integrity sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg== +caniuse-lite@^1.0.30001400: + version "1.0.30001439" + resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001439.tgz#ab7371faeb4adff4b74dad1718a6fd122e45d9cb" + integrity sha512-1MgUzEkoMO6gKfXflStpYgZDlFM7M/ck/bgfVCACO5vnAf0fXoNVHdWtqGU+MYca+4bL9Z5bpOVmR33cWW9G2A== + capture-exit@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/capture-exit/-/capture-exit-2.0.0.tgz#fb953bfaebeb781f62898239dabb426d08a509a4" @@ -922,7 +1025,7 @@ capture-exit@^2.0.0: caseless@~0.12.0: version "0.12.0" resolved "https://registry.yarnpkg.com/caseless/-/caseless-0.12.0.tgz#1b681c21ff84033c826543090689420d187151dc" - integrity sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw= + integrity sha512-4tYFyifaFfGacoiObjJegolkwSU4xQNGbVgUiNYVUxbQ2x2lUsFvY4hVgVzGiIe6WLOPqycWXA40l+PWsxthUw== chalk@^2.0.0, chalk@^2.0.1, chalk@^2.4.2: version "2.4.2" @@ -934,9 +1037,9 @@ chalk@^2.0.0, chalk@^2.0.1, chalk@^2.4.2: supports-color "^5.3.0" chalk@^4.0.0: - version "4.1.0" - resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.0.tgz#4e14870a618d9e2edd97dd8345fd9d9dc315646a" - integrity sha512-qwx12AxXe2Q5xQ43Ac//I6v5aXTipYrSESdOgzrN+9XjgEpyjpKuvSGaN4qE93f7TQTlerQQ8S+EQ0EyDoVL1A== + version "4.1.2" + resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01" + integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA== dependencies: ansi-styles "^4.1.0" supports-color "^7.1.0" @@ -965,24 +1068,24 @@ cliui@^5.0.0: strip-ansi "^5.2.0" wrap-ansi "^5.1.0" -cliui@^6.0.0: - version "6.0.0" - resolved "http://registry.npm.dtstack.com/cliui/-/cliui-6.0.0.tgz#511d702c0c4e41ca156d7d0e96021f23e13225b1" - integrity sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ== +cliui@^7.0.2: + version "7.0.4" + resolved "https://registry.yarnpkg.com/cliui/-/cliui-7.0.4.tgz#a0265ee655476fc807aea9df3df8df7783808b4f" + integrity sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ== dependencies: string-width "^4.2.0" strip-ansi "^6.0.0" - wrap-ansi "^6.2.0" + wrap-ansi "^7.0.0" co@^4.6.0: version "4.6.0" resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184" - integrity sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ= + integrity sha512-QVb0dM5HvG+uaxitm8wONl7jltx8dqhfU33DcqtOZcLSVIKSDDLDi7+0LbAKiyI8hD9u42m2YxXSkMGWThaecQ== collection-visit@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/collection-visit/-/collection-visit-1.0.0.tgz#4bc0373c164bc3291b4d368c829cf1a80a59dca0" - integrity sha1-S8A3PBZLwykbTTaMgpzxqApZ3KA= + integrity sha512-lNkKvzEeMBBjUGHZ+q6z9pSJla0KWAQPvtzhEV9+iGyQYG+pBpl7xKDhxoNSOZH2hhv0v5k0y2yAM4o4SjoSkw== dependencies: map-visit "^1.0.0" object-visit "^1.0.0" @@ -1004,7 +1107,7 @@ color-convert@^2.0.1: color-name@1.1.3: version "1.1.3" resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25" - integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU= + integrity sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw== color-name@~1.1.4: version "1.1.4" @@ -1020,8 +1123,8 @@ combined-stream@^1.0.6, combined-stream@~1.0.6: compare-func@^2.0.0: version "2.0.0" - resolved "http://registry.npm.dtstack.com/compare-func/-/compare-func-2.0.0.tgz#fb65e75edbddfd2e568554e8b5b05fff7a51fcb3" - integrity sha1-+2XnXtvd/S5WhVTotbBf/3pR/LM= + resolved "https://registry.yarnpkg.com/compare-func/-/compare-func-2.0.0.tgz#fb65e75edbddfd2e568554e8b5b05fff7a51fcb3" + integrity sha512-zHig5N+tPWARooBnb0Zx1MFcdfpyJrfTJ3Y5L+IFvUm8rM74hHz66z0gw0x4tijh5CorKkKUCnW82R2vmpeCRA== dependencies: array-ify "^1.0.0" dot-prop "^5.1.0" @@ -1034,12 +1137,12 @@ component-emitter@^1.2.1: concat-map@0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" - integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s= + integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg== concat-stream@^2.0.0: version "2.0.0" - resolved "http://registry.npm.dtstack.com/concat-stream/-/concat-stream-2.0.0.tgz#414cf5af790a48c60ab9be4527d56d5e41133cb1" - integrity sha1-QUz1r3kKSMYKub5FJ9VtXkETPLE= + resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-2.0.0.tgz#414cf5af790a48c60ab9be4527d56d5e41133cb1" + integrity sha512-MWufYdFw53ccGjCA+Ol7XJYpAlW6/prSMzuPOTRnJGcGzuhLn4Scrz7qf6o8bROZ514ltazcIFJZevcfbo0x7A== dependencies: buffer-from "^1.0.0" inherits "^2.0.3" @@ -1047,51 +1150,51 @@ concat-stream@^2.0.0: typedarray "^0.0.6" conventional-changelog-angular@^5.0.12: - version "5.0.12" - resolved "http://registry.npm.dtstack.com/conventional-changelog-angular/-/conventional-changelog-angular-5.0.12.tgz#c979b8b921cbfe26402eb3da5bbfda02d865a2b9" - integrity sha1-yXm4uSHL/iZALrPaW7/aAthlork= + version "5.0.13" + resolved "https://registry.yarnpkg.com/conventional-changelog-angular/-/conventional-changelog-angular-5.0.13.tgz#896885d63b914a70d4934b59d2fe7bde1832b28c" + integrity sha512-i/gipMxs7s8L/QeuavPF2hLnJgH6pEZAttySB6aiQLWcX3puWDL3ACVmvBhJGxnAy52Qc15ua26BufY6KpmrVA== dependencies: compare-func "^2.0.0" q "^1.5.1" conventional-changelog-atom@^2.0.8: version "2.0.8" - resolved "http://registry.npm.dtstack.com/conventional-changelog-atom/-/conventional-changelog-atom-2.0.8.tgz#a759ec61c22d1c1196925fca88fe3ae89fd7d8de" - integrity sha1-p1nsYcItHBGWkl/KiP466J/X2N4= + resolved "https://registry.yarnpkg.com/conventional-changelog-atom/-/conventional-changelog-atom-2.0.8.tgz#a759ec61c22d1c1196925fca88fe3ae89fd7d8de" + integrity sha512-xo6v46icsFTK3bb7dY/8m2qvc8sZemRgdqLb/bjpBsH2UyOS8rKNTgcb5025Hri6IpANPApbXMg15QLb1LJpBw== dependencies: q "^1.5.1" conventional-changelog-codemirror@^2.0.8: version "2.0.8" - resolved "http://registry.npm.dtstack.com/conventional-changelog-codemirror/-/conventional-changelog-codemirror-2.0.8.tgz#398e9530f08ce34ec4640af98eeaf3022eb1f7dc" - integrity sha1-OY6VMPCM407EZAr5jurzAi6x99w= + resolved "https://registry.yarnpkg.com/conventional-changelog-codemirror/-/conventional-changelog-codemirror-2.0.8.tgz#398e9530f08ce34ec4640af98eeaf3022eb1f7dc" + integrity sha512-z5DAsn3uj1Vfp7po3gpt2Boc+Bdwmw2++ZHa5Ak9k0UKsYAO5mH1UBTN0qSCuJZREIhX6WU4E1p3IW2oRCNzQw== dependencies: q "^1.5.1" conventional-changelog-config-spec@2.1.0: version "2.1.0" - resolved "http://registry.npm.dtstack.com/conventional-changelog-config-spec/-/conventional-changelog-config-spec-2.1.0.tgz#874a635287ef8b581fd8558532bf655d4fb59f2d" + resolved "https://registry.yarnpkg.com/conventional-changelog-config-spec/-/conventional-changelog-config-spec-2.1.0.tgz#874a635287ef8b581fd8558532bf655d4fb59f2d" integrity sha512-IpVePh16EbbB02V+UA+HQnnPIohgXvJRxHcS5+Uwk4AT5LjzCZJm5sp/yqs5C6KZJ1jMsV4paEV13BN1pvDuxQ== -conventional-changelog-conventionalcommits@4.5.0, conventional-changelog-conventionalcommits@^4.5.0: - version "4.5.0" - resolved "http://registry.npm.dtstack.com/conventional-changelog-conventionalcommits/-/conventional-changelog-conventionalcommits-4.5.0.tgz#a02e0b06d11d342fdc0f00c91d78265ed0bc0a62" - integrity sha1-oC4LBtEdNC/cDwDJHXgmXtC8CmI= +conventional-changelog-conventionalcommits@4.6.3, conventional-changelog-conventionalcommits@^4.5.0: + version "4.6.3" + resolved "https://registry.yarnpkg.com/conventional-changelog-conventionalcommits/-/conventional-changelog-conventionalcommits-4.6.3.tgz#0765490f56424b46f6cb4db9135902d6e5a36dc2" + integrity sha512-LTTQV4fwOM4oLPad317V/QNQ1FY4Hju5qeBIM1uTHbrnCE+Eg4CdRZ3gO2pUeR+tzWdp80M2j3qFFEDWVqOV4g== dependencies: compare-func "^2.0.0" lodash "^4.17.15" q "^1.5.1" conventional-changelog-core@^4.2.1: - version "4.2.2" - resolved "http://registry.npm.dtstack.com/conventional-changelog-core/-/conventional-changelog-core-4.2.2.tgz#f0897df6d53b5d63dec36b9442bd45354f8b3ce5" - integrity sha512-7pDpRUiobQDNkwHyJG7k9f6maPo9tfPzkSWbRq97GGiZqisElhnvUZSvyQH20ogfOjntB5aadvv6NNcKL1sReg== + version "4.2.4" + resolved "https://registry.yarnpkg.com/conventional-changelog-core/-/conventional-changelog-core-4.2.4.tgz#e50d047e8ebacf63fac3dc67bf918177001e1e9f" + integrity sha512-gDVS+zVJHE2v4SLc6B0sLsPiloR0ygU7HaDW14aNJE1v4SlqJPILPl/aJC7YdtRE4CybBf8gDwObBvKha8Xlyg== dependencies: add-stream "^1.0.0" - conventional-changelog-writer "^4.0.18" + conventional-changelog-writer "^5.0.0" conventional-commits-parser "^3.2.0" dateformat "^3.0.0" - get-pkg-repo "^1.0.0" + get-pkg-repo "^4.0.0" git-raw-commits "^2.0.8" git-remote-origin-url "^2.0.0" git-semver-tags "^4.1.1" @@ -1100,59 +1203,57 @@ conventional-changelog-core@^4.2.1: q "^1.5.1" read-pkg "^3.0.0" read-pkg-up "^3.0.0" - shelljs "^0.8.3" through2 "^4.0.0" conventional-changelog-ember@^2.0.9: version "2.0.9" - resolved "http://registry.npm.dtstack.com/conventional-changelog-ember/-/conventional-changelog-ember-2.0.9.tgz#619b37ec708be9e74a220f4dcf79212ae1c92962" - integrity sha1-YZs37HCL6edKIg9Nz3khKuHJKWI= + resolved "https://registry.yarnpkg.com/conventional-changelog-ember/-/conventional-changelog-ember-2.0.9.tgz#619b37ec708be9e74a220f4dcf79212ae1c92962" + integrity sha512-ulzIReoZEvZCBDhcNYfDIsLTHzYHc7awh+eI44ZtV5cx6LVxLlVtEmcO+2/kGIHGtw+qVabJYjdI5cJOQgXh1A== dependencies: q "^1.5.1" conventional-changelog-eslint@^3.0.9: version "3.0.9" - resolved "http://registry.npm.dtstack.com/conventional-changelog-eslint/-/conventional-changelog-eslint-3.0.9.tgz#689bd0a470e02f7baafe21a495880deea18b7cdb" - integrity sha1-aJvQpHDgL3uq/iGklYgN7qGLfNs= + resolved "https://registry.yarnpkg.com/conventional-changelog-eslint/-/conventional-changelog-eslint-3.0.9.tgz#689bd0a470e02f7baafe21a495880deea18b7cdb" + integrity sha512-6NpUCMgU8qmWmyAMSZO5NrRd7rTgErjrm4VASam2u5jrZS0n38V7Y9CzTtLT2qwz5xEChDR4BduoWIr8TfwvXA== dependencies: q "^1.5.1" conventional-changelog-express@^2.0.6: version "2.0.6" - resolved "http://registry.npm.dtstack.com/conventional-changelog-express/-/conventional-changelog-express-2.0.6.tgz#420c9d92a347b72a91544750bffa9387665a6ee8" - integrity sha1-QgydkqNHtyqRVEdQv/qTh2Zabug= + resolved "https://registry.yarnpkg.com/conventional-changelog-express/-/conventional-changelog-express-2.0.6.tgz#420c9d92a347b72a91544750bffa9387665a6ee8" + integrity sha512-SDez2f3iVJw6V563O3pRtNwXtQaSmEfTCaTBPCqn0oG0mfkq0rX4hHBq5P7De2MncoRixrALj3u3oQsNK+Q0pQ== dependencies: q "^1.5.1" conventional-changelog-jquery@^3.0.11: version "3.0.11" - resolved "http://registry.npm.dtstack.com/conventional-changelog-jquery/-/conventional-changelog-jquery-3.0.11.tgz#d142207400f51c9e5bb588596598e24bba8994bf" - integrity sha1-0UIgdAD1HJ5btYhZZZjiS7qJlL8= + resolved "https://registry.yarnpkg.com/conventional-changelog-jquery/-/conventional-changelog-jquery-3.0.11.tgz#d142207400f51c9e5bb588596598e24bba8994bf" + integrity sha512-x8AWz5/Td55F7+o/9LQ6cQIPwrCjfJQ5Zmfqi8thwUEKHstEn4kTIofXub7plf1xvFA2TqhZlq7fy5OmV6BOMw== dependencies: q "^1.5.1" conventional-changelog-jshint@^2.0.9: version "2.0.9" - resolved "http://registry.npm.dtstack.com/conventional-changelog-jshint/-/conventional-changelog-jshint-2.0.9.tgz#f2d7f23e6acd4927a238555d92c09b50fe3852ff" - integrity sha1-8tfyPmrNSSeiOFVdksCbUP44Uv8= + resolved "https://registry.yarnpkg.com/conventional-changelog-jshint/-/conventional-changelog-jshint-2.0.9.tgz#f2d7f23e6acd4927a238555d92c09b50fe3852ff" + integrity sha512-wMLdaIzq6TNnMHMy31hql02OEQ8nCQfExw1SE0hYL5KvU+JCTuPaDO+7JiogGT2gJAxiUGATdtYYfh+nT+6riA== dependencies: compare-func "^2.0.0" q "^1.5.1" conventional-changelog-preset-loader@^2.3.4: version "2.3.4" - resolved "http://registry.npm.dtstack.com/conventional-changelog-preset-loader/-/conventional-changelog-preset-loader-2.3.4.tgz#14a855abbffd59027fd602581f1f34d9862ea44c" - integrity sha1-FKhVq7/9WQJ/1gJYHx802YYupEw= + resolved "https://registry.yarnpkg.com/conventional-changelog-preset-loader/-/conventional-changelog-preset-loader-2.3.4.tgz#14a855abbffd59027fd602581f1f34d9862ea44c" + integrity sha512-GEKRWkrSAZeTq5+YjUZOYxdHq+ci4dNwHvpaBC3+ENalzFWuCWa9EZXSuZBpkr72sMdKB+1fyDV4takK1Lf58g== -conventional-changelog-writer@^4.0.18: - version "4.1.0" - resolved "http://registry.npm.dtstack.com/conventional-changelog-writer/-/conventional-changelog-writer-4.1.0.tgz#1ca7880b75aa28695ad33312a1f2366f4b12659f" - integrity sha512-WwKcUp7WyXYGQmkLsX4QmU42AZ1lqlvRW9mqoyiQzdD+rJWbTepdWoKJuwXTS+yq79XKnQNa93/roViPQrAQgw== +conventional-changelog-writer@^5.0.0: + version "5.0.1" + resolved "https://registry.yarnpkg.com/conventional-changelog-writer/-/conventional-changelog-writer-5.0.1.tgz#e0757072f045fe03d91da6343c843029e702f359" + integrity sha512-5WsuKUfxW7suLblAbFnxAcrvf6r+0b7GvNaWUwUIk0bXMnENP/PEieGKVUQrjPqwPT4o3EPAASBXiY6iHooLOQ== dependencies: - compare-func "^2.0.0" conventional-commits-filter "^2.0.7" dateformat "^3.0.0" - handlebars "^4.7.6" + handlebars "^4.7.7" json-stringify-safe "^5.0.1" lodash "^4.17.15" meow "^8.0.0" @@ -1160,10 +1261,10 @@ conventional-changelog-writer@^4.0.18: split "^1.0.0" through2 "^4.0.0" -conventional-changelog@3.1.24: - version "3.1.24" - resolved "http://registry.npm.dtstack.com/conventional-changelog/-/conventional-changelog-3.1.24.tgz#ebd180b0fd1b2e1f0095c4b04fd088698348a464" - integrity sha1-69GAsP0bLh8AlcSwT9CIaYNIpGQ= +conventional-changelog@3.1.25: + version "3.1.25" + resolved "https://registry.yarnpkg.com/conventional-changelog/-/conventional-changelog-3.1.25.tgz#3e227a37d15684f5aa1fb52222a6e9e2536ccaff" + integrity sha512-ryhi3fd1mKf3fSjbLXOfK2D06YwKNic1nC9mWqybBHdObPd8KJ2vjaXZfYj1U23t+V8T8n0d7gwnc9XbIdFbyQ== dependencies: conventional-changelog-angular "^5.0.12" conventional-changelog-atom "^2.0.8" @@ -1179,55 +1280,57 @@ conventional-changelog@3.1.24: conventional-commits-filter@^2.0.7: version "2.0.7" - resolved "http://registry.npm.dtstack.com/conventional-commits-filter/-/conventional-commits-filter-2.0.7.tgz#f8d9b4f182fce00c9af7139da49365b136c8a0b3" - integrity sha1-+Nm08YL84Aya9xOdpJNlsTbIoLM= + resolved "https://registry.yarnpkg.com/conventional-commits-filter/-/conventional-commits-filter-2.0.7.tgz#f8d9b4f182fce00c9af7139da49365b136c8a0b3" + integrity sha512-ASS9SamOP4TbCClsRHxIHXRfcGCnIoQqkvAzCSbZzTFLfcTqJVugB0agRgsEELsqaeWgsXv513eS116wnlSSPA== dependencies: lodash.ismatch "^4.4.0" modify-values "^1.0.0" conventional-commits-parser@^3.2.0: - version "3.2.0" - resolved "http://registry.npm.dtstack.com/conventional-commits-parser/-/conventional-commits-parser-3.2.0.tgz#9e261b139ca4b7b29bcebbc54460da36894004ca" - integrity sha1-niYbE5ykt7KbzrvFRGDaNolABMo= + version "3.2.4" + resolved "https://registry.yarnpkg.com/conventional-commits-parser/-/conventional-commits-parser-3.2.4.tgz#a7d3b77758a202a9b2293d2112a8d8052c740972" + integrity sha512-nK7sAtfi+QXbxHCYfhpZsfRtaitZLIA6889kFIouLvz6repszQDgxBu7wf2WbU+Dco7sAnNCJYERCwt54WPC2Q== dependencies: JSONStream "^1.0.4" is-text-path "^1.0.1" lodash "^4.17.15" meow "^8.0.0" - split2 "^2.0.0" + split2 "^3.0.0" through2 "^4.0.0" - trim-off-newlines "^1.0.0" -conventional-recommended-bump@6.0.11: - version "6.0.11" - resolved "http://registry.npm.dtstack.com/conventional-recommended-bump/-/conventional-recommended-bump-6.0.11.tgz#fcc39acb51d1946b63fc478737d1e52712f36356" - integrity sha1-/MOay1HRlGtj/EeHN9HlJxLzY1Y= +conventional-recommended-bump@6.1.0: + version "6.1.0" + resolved "https://registry.yarnpkg.com/conventional-recommended-bump/-/conventional-recommended-bump-6.1.0.tgz#cfa623285d1de554012f2ffde70d9c8a22231f55" + integrity sha512-uiApbSiNGM/kkdL9GTOLAqC4hbptObFo4wW2QRyHsKciGAfQuLU1ShZ1BIVI/+K2BE/W1AWYQMCXAsv4dyKPaw== dependencies: concat-stream "^2.0.0" conventional-changelog-preset-loader "^2.3.4" conventional-commits-filter "^2.0.7" conventional-commits-parser "^3.2.0" - git-raw-commits "2.0.0" + git-raw-commits "^2.0.8" git-semver-tags "^4.1.1" meow "^8.0.0" q "^1.5.1" convert-source-map@^1.4.0, convert-source-map@^1.7.0: - version "1.7.0" - resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.7.0.tgz#17a2cb882d7f77d3490585e2ce6c524424a3a442" - integrity sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA== - dependencies: - safe-buffer "~5.1.1" + version "1.9.0" + resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.9.0.tgz#7faae62353fb4213366d0ca98358d22e8368b05f" + integrity sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A== copy-descriptor@^0.1.0: version "0.1.1" resolved "https://registry.yarnpkg.com/copy-descriptor/-/copy-descriptor-0.1.1.tgz#676f6eb3c39997c2ee1ac3a924fd6124748f578d" - integrity sha1-Z29us8OZl8LuGsOpJP1hJHSPV40= + integrity sha512-XgZ0pFcakEUlbwQEVNg3+QAis1FyTL3Qel9FYy8pSkQqoG3PNoT0bOCQtOXcOkur21r2Eq2kI+IE+gsmAEVlYw== -core-util-is@1.0.2, core-util-is@~1.0.0: +core-util-is@1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7" - integrity sha1-tf1UIgqivFq1eqtxQMlAdUUDwac= + integrity sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ== + +core-util-is@~1.0.0: + version "1.0.3" + resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.3.tgz#a6042d3634c2b27e9328f837b965fac83808db85" + integrity sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ== cross-spawn@^6.0.0: version "6.0.5" @@ -1261,29 +1364,15 @@ cssstyle@^1.0.0: dependencies: cssom "0.3.x" -currently-unhandled@^0.4.1: - version "0.4.1" - resolved "http://registry.npm.dtstack.com/currently-unhandled/-/currently-unhandled-0.4.1.tgz#988df33feab191ef799a61369dd76c17adf957ea" - integrity sha1-mI3zP+qxke95mmE2nddsF635V+o= - dependencies: - array-find-index "^1.0.1" - -dargs@^4.0.1: - version "4.1.0" - resolved "http://registry.npm.dtstack.com/dargs/-/dargs-4.1.0.tgz#03a9dbb4b5c2f139bf14ae53f0b8a2a6a86f4e17" - integrity sha1-A6nbtLXC8Tm/FK5T8LiipqhvThc= - dependencies: - number-is-nan "^1.0.0" - dargs@^7.0.0: version "7.0.0" - resolved "http://registry.npm.dtstack.com/dargs/-/dargs-7.0.0.tgz#04015c41de0bcb69ec84050f3d9be0caf8d6d5cc" - integrity sha1-BAFcQd4Ly2nshAUPPZvgyvjW1cw= + resolved "https://registry.yarnpkg.com/dargs/-/dargs-7.0.0.tgz#04015c41de0bcb69ec84050f3d9be0caf8d6d5cc" + integrity sha512-2iy1EkLdlBzQGvbweYRFxmFath8+K7+AKB0TlhHWkNuH+TmovaMH/Wp7V7R4u7f4SnX3OgLsU9t1NI9ioDnUpg== dashdash@^1.12.0: version "1.14.1" resolved "https://registry.yarnpkg.com/dashdash/-/dashdash-1.14.1.tgz#853cfa0f7cbe2fed5de20326b8dd581035f6e2f0" - integrity sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA= + integrity sha512-jRFi8UDGo6j+odZiEpjazZaWqEal3w/basFjQHQEwVtZJGDpxbH1MeYluwCS8Xq5wmLJooDlMgvVarmWfGM44g== dependencies: assert-plus "^1.0.0" @@ -1298,8 +1387,8 @@ data-urls@^1.0.0: dateformat@^3.0.0: version "3.0.3" - resolved "http://registry.npm.dtstack.com/dateformat/-/dateformat-3.0.3.tgz#a6e37499a4d9a9cf85ef5872044d62901c9889ae" - integrity sha1-puN0maTZqc+F71hyBE1ikByYia4= + resolved "https://registry.yarnpkg.com/dateformat/-/dateformat-3.0.3.tgz#a6e37499a4d9a9cf85ef5872044d62901c9889ae" + integrity sha512-jyCETtSl3VMZMWeRo7iY1FL19ges1t55hMo5yaam4Jrsm5EPL89UQkoQRyiI+Yf4k8r2ZpdngkV8hr1lIdjb3Q== debug@^2.2.0, debug@^2.3.3: version "2.6.9" @@ -1309,53 +1398,54 @@ debug@^2.2.0, debug@^2.3.3: ms "2.0.0" debug@^4.0.1, debug@^4.1.0, debug@^4.1.1: - version "4.1.1" - resolved "https://registry.yarnpkg.com/debug/-/debug-4.1.1.tgz#3b72260255109c6b589cee050f1d516139664791" - integrity sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw== + version "4.3.4" + resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.4.tgz#1319f6579357f2338d3337d2cdd4914bb5dcc865" + integrity sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ== dependencies: - ms "^2.1.1" + ms "2.1.2" -decamelize-keys@^1.0.0, decamelize-keys@^1.1.0: - version "1.1.0" - resolved "http://registry.npm.dtstack.com/decamelize-keys/-/decamelize-keys-1.1.0.tgz#d171a87933252807eb3cb61dc1c1445d078df2d9" - integrity sha1-0XGoeTMlKAfrPLYdwcFEXQeN8tk= +decamelize-keys@^1.1.0: + version "1.1.1" + resolved "https://registry.yarnpkg.com/decamelize-keys/-/decamelize-keys-1.1.1.tgz#04a2d523b2f18d80d0158a43b895d56dff8d19d8" + integrity sha512-WiPxgEirIV0/eIOMcnFBA3/IJZAZqKnwAwWyvvdi4lsr1WCN22nhdf/3db3DoZcUjTV2SqfzIwNyp6y2xs3nmg== dependencies: decamelize "^1.1.0" map-obj "^1.0.0" -decamelize@^1.1.0, decamelize@^1.1.2, decamelize@^1.2.0: +decamelize@^1.1.0, decamelize@^1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290" - integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA= + integrity sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA== decode-uri-component@^0.2.0: - version "0.2.0" - resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.0.tgz#eb3913333458775cb84cd1a1fae062106bb87545" - integrity sha1-6zkTMzRYd1y4TNGh+uBiEGu4dUU= + version "0.2.2" + resolved "https://registry.yarnpkg.com/decode-uri-component/-/decode-uri-component-0.2.2.tgz#e69dbe25d37941171dd540e024c444cd5188e1e9" + integrity sha512-FqUYQ+8o158GyGTrMFJms9qh3CqTKvAqgqsTnkLI8sKu0028orqBhxNMFkFen0zGyg6epACD32pjVk58ngIErQ== deep-is@^0.1.3, deep-is@~0.1.3: - version "0.1.3" - resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34" - integrity sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ= + version "0.1.4" + resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.4.tgz#a6f2dce612fadd2ef1f519b73551f17e85199831" + integrity sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ== -define-properties@^1.1.2, define-properties@^1.1.3: - version "1.1.3" - resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.3.tgz#cf88da6cbee26fe6db7094f61d870cbd84cee9f1" - integrity sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ== +define-properties@^1.1.3, define-properties@^1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.4.tgz#0b14d7bd7fbeb2f3572c3a7eda80ea5d57fb05b1" + integrity sha512-uckOqKcfaVvtBdsVkdPv3XjveQJsNQqmhXgRi8uhvWWuPYZCNlzT8qAyblUgNoXdHdjMTzAqeGjAoli8f+bzPA== dependencies: - object-keys "^1.0.12" + has-property-descriptors "^1.0.0" + object-keys "^1.1.1" define-property@^0.2.5: version "0.2.5" resolved "https://registry.yarnpkg.com/define-property/-/define-property-0.2.5.tgz#c35b1ef918ec3c990f9a5bc57be04aacec5c8116" - integrity sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY= + integrity sha512-Rr7ADjQZenceVOAKop6ALkkRAmH1A4Gx9hV/7ZujPUN2rkATqFO0JZLZInbAjpZYoJ1gUx8MRMQVkYemcbMSTA== dependencies: is-descriptor "^0.1.0" define-property@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/define-property/-/define-property-1.0.0.tgz#769ebaaf3f4a63aad3af9e8d304c9bbe79bfb0e6" - integrity sha1-dp66rz9KY6rTr56NMEybvnm/sOY= + integrity sha512-cZTYKFWspt9jZsMscWo8sc/5lbPC9Q0N5nBLgb+Yd915iL3udB1uFgS3B8YCx66UVHq018DAVFoee7x+gxggeA== dependencies: is-descriptor "^1.0.0" @@ -1370,21 +1460,21 @@ define-property@^2.0.2: delayed-stream@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/delayed-stream/-/delayed-stream-1.0.0.tgz#df3ae199acadfb7d440aaae0b29e2272b24ec619" - integrity sha1-3zrhmayt+31ECqrgsp4icrJOxhk= + integrity sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ== detect-indent@^6.0.0: - version "6.0.0" - resolved "http://registry.npm.dtstack.com/detect-indent/-/detect-indent-6.0.0.tgz#0abd0f549f69fc6659a254fe96786186b6f528fd" - integrity sha512-oSyFlqaTHCItVRGK5RmrmjB+CmaMOW7IaNA/kdxqhoa6d17j/5ce9O9eWXmV/KEdRwqpQA+Vqe8a8Bsybu4YnA== + version "6.1.0" + resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-6.1.0.tgz#592485ebbbf6b3b1ab2be175c8393d04ca0d57e6" + integrity sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA== detect-newline@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-2.1.0.tgz#f41f1c10be4b00e87b5f13da680759f2c5bfd3e2" - integrity sha1-9B8cEL5LAOh7XxPaaAdZ8sW/0+I= + integrity sha512-CwffZFvlJffUg9zZA0uqrjQayUTC8ob94pnr5sFwaVv3IOmkfUHcWH+jXaQK3askE51Cqe8/9Ql/0uXNwqZ8Zg== detect-newline@^3.1.0: version "3.1.0" - resolved "http://registry.npm.dtstack.com/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651" + resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-3.1.0.tgz#576f5dfc63ae1a192ff192d8ad3af6308991b651" integrity sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA== diff-sequences@^24.9.0: @@ -1408,14 +1498,14 @@ domexception@^1.0.1: dot-prop@^5.1.0: version "5.3.0" - resolved "http://registry.npm.dtstack.com/dot-prop/-/dot-prop-5.3.0.tgz#90ccce708cd9cd82cc4dc8c3ddd9abdd55b20e88" - integrity sha1-kMzOcIzZzYLMTcjD3dmr3VWyDog= + resolved "https://registry.yarnpkg.com/dot-prop/-/dot-prop-5.3.0.tgz#90ccce708cd9cd82cc4dc8c3ddd9abdd55b20e88" + integrity sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q== dependencies: is-obj "^2.0.0" dotgitignore@^2.1.0: version "2.1.0" - resolved "http://registry.npm.dtstack.com/dotgitignore/-/dotgitignore-2.1.0.tgz#a4b15a4e4ef3cf383598aaf1dfa4a04bcc089b7b" + resolved "https://registry.yarnpkg.com/dotgitignore/-/dotgitignore-2.1.0.tgz#a4b15a4e4ef3cf383598aaf1dfa4a04bcc089b7b" integrity sha512-sCm11ak2oY6DglEPpCB8TixLjWAxd3kJTs6UIcSasNYxXdFPV+YKlye92c8H4kKFqV5qYMIh7d+cYecEg0dIkA== dependencies: find-up "^3.0.0" @@ -1424,11 +1514,16 @@ dotgitignore@^2.1.0: ecc-jsbn@~0.1.1: version "0.1.2" resolved "https://registry.yarnpkg.com/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz#3a83a904e54353287874c564b7549386849a98c9" - integrity sha1-OoOpBOVDUyh4dMVkt1SThoSamMk= + integrity sha512-eh9O+hwRHNbG4BLTjEl3nw044CkGm5X6LoaCf7LPp7UU8Qrt47JYNi6nPX8xjW97TKGKm1ouctg0QSpZe9qrnw== dependencies: jsbn "~0.1.0" safer-buffer "^2.1.0" +electron-to-chromium@^1.4.251: + version "1.4.284" + resolved "https://registry.yarnpkg.com/electron-to-chromium/-/electron-to-chromium-1.4.284.tgz#61046d1e4cab3a25238f6bf7413795270f125592" + integrity sha512-M8WEXFuKXMYMVr45fo8mq0wUrrJHheiKZf6BArTKk9ZBYCKJEOU5H8cdWgDT+qCVZf7Na4lVUaZsA+h6uA9+PA== + emoji-regex@^7.0.1: version "7.0.3" resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-7.0.3.tgz#933a04052860c85e83c122479c4748a8e4c72156" @@ -1436,7 +1531,7 @@ emoji-regex@^7.0.1: emoji-regex@^8.0.0: version "8.0.0" - resolved "http://registry.npm.dtstack.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" + resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37" integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A== end-of-stream@^1.1.0: @@ -1453,29 +1548,48 @@ enquirer@^2.3.5: dependencies: ansi-colors "^4.1.1" -error-ex@^1.2.0, error-ex@^1.3.1: +error-ex@^1.3.1: version "1.3.2" resolved "https://registry.yarnpkg.com/error-ex/-/error-ex-1.3.2.tgz#b4ac40648107fdcdcfae242f428bea8a14d4f1bf" integrity sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g== dependencies: is-arrayish "^0.2.1" -es-abstract@^1.17.0-next.1, es-abstract@^1.17.2, es-abstract@^1.17.5: - version "1.17.6" - resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.17.6.tgz#9142071707857b2cacc7b89ecb670316c3e2d52a" - integrity sha512-Fr89bON3WFyUi5EvAeI48QTWX0AyekGgLA8H+c+7fbfCkJwRWRMLd8CQedNEyJuoYYhmtEqY92pgte1FAhBlhw== +es-abstract@^1.19.0, es-abstract@^1.20.4: + version "1.20.5" + resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.20.5.tgz#e6dc99177be37cacda5988e692c3fa8b218e95d2" + integrity sha512-7h8MM2EQhsCA7pU/Nv78qOXFpD8Rhqd12gYiSJVkrH9+e8VuA8JlPJK/hQjjlLv6pJvx/z1iRFKzYb0XT/RuAQ== dependencies: + call-bind "^1.0.2" es-to-primitive "^1.2.1" function-bind "^1.1.1" + function.prototype.name "^1.1.5" + get-intrinsic "^1.1.3" + get-symbol-description "^1.0.0" + gopd "^1.0.1" has "^1.0.3" - has-symbols "^1.0.1" - is-callable "^1.2.0" - is-regex "^1.1.0" - object-inspect "^1.7.0" + has-property-descriptors "^1.0.0" + has-symbols "^1.0.3" + internal-slot "^1.0.3" + is-callable "^1.2.7" + is-negative-zero "^2.0.2" + is-regex "^1.1.4" + is-shared-array-buffer "^1.0.2" + is-string "^1.0.7" + is-weakref "^1.0.2" + object-inspect "^1.12.2" object-keys "^1.1.1" - object.assign "^4.1.0" - string.prototype.trimend "^1.0.1" - string.prototype.trimstart "^1.0.1" + object.assign "^4.1.4" + regexp.prototype.flags "^1.4.3" + safe-regex-test "^1.0.0" + string.prototype.trimend "^1.0.6" + string.prototype.trimstart "^1.0.6" + unbox-primitive "^1.0.2" + +es-array-method-boxes-properly@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/es-array-method-boxes-properly/-/es-array-method-boxes-properly-1.0.0.tgz#873f3e84418de4ee19c5be752990b2e44718d09e" + integrity sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA== es-to-primitive@^1.2.1: version "1.2.1" @@ -1486,10 +1600,25 @@ es-to-primitive@^1.2.1: is-date-object "^1.0.1" is-symbol "^1.0.2" +escalade@^3.1.1: + version "3.1.1" + resolved "https://registry.yarnpkg.com/escalade/-/escalade-3.1.1.tgz#d8cfdc7000965c5a0174b4a82eaa5c0552742e40" + integrity sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw== + escape-string-regexp@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4" - integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ= + integrity sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg== + +escape-string-regexp@^2.0.0: + version "2.0.0" + resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-2.0.0.tgz#a30304e99daa32e23b2fd20f51babd07cffca344" + integrity sha512-UpzcLCXolUWcNu5HtVMHYdXJjArjsF9C0aNnquZYY4uW/Vu0miy5YoWvbV345HauVvcAUnpRuhMMcqTcGOY2+w== + +escape-string-regexp@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz#14ba83a5d373e3d311e5afca29cf5bfad965bf34" + integrity sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA== escodegen@^1.9.1: version "1.14.3" @@ -1508,12 +1637,12 @@ eslint-config-google@^0.14.0: resolved "https://registry.yarnpkg.com/eslint-config-google/-/eslint-config-google-0.14.0.tgz#4f5f8759ba6e11b424294a219dbfa18c508bcc1a" integrity sha512-WsbX4WbjuMvTdeVL6+J3rK1RGhCTqjsFjX7UMSMgZiyxxaNLkoJENbrGExzERFeoTpGw3F3FypTiWAP9ZXzkEw== -eslint-scope@^5.0.0, eslint-scope@^5.1.0: - version "5.1.0" - resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.0.tgz#d0f971dfe59c69e0cada684b23d49dbf82600ce5" - integrity sha512-iiGRvtxWqgtx5m8EyQUJihBloE4EnYeGE/bz1wSPwJE6tZuJUtHlhqDM4Xj2ukE8Dyy1+HCZ4hE0fzIVMzb58w== +eslint-scope@^5.0.0, eslint-scope@^5.1.1: + version "5.1.1" + resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c" + integrity sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw== dependencies: - esrecurse "^4.1.0" + esrecurse "^4.3.0" estraverse "^4.1.1" eslint-utils@^2.0.0, eslint-utils@^2.1.0: @@ -1528,28 +1657,37 @@ eslint-visitor-keys@^1.1.0, eslint-visitor-keys@^1.3.0: resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz#30ebd1ef7c2fdff01c3a4f151044af25fab0523e" integrity sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ== +eslint-visitor-keys@^2.0.0: + version "2.1.0" + resolved "https://registry.yarnpkg.com/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz#f65328259305927392c938ed44eb0a5c9b2bd303" + integrity sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw== + eslint@^7.7.0: - version "7.7.0" - resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.7.0.tgz#18beba51411927c4b64da0a8ceadefe4030d6073" - integrity sha512-1KUxLzos0ZVsyL81PnRN335nDtQ8/vZUD6uMtWbF+5zDtjKcsklIi78XoE0MVL93QvWTu+E5y44VyyCsOMBrIg== + version "7.32.0" + resolved "https://registry.yarnpkg.com/eslint/-/eslint-7.32.0.tgz#c6d328a14be3fb08c8d1d21e12c02fdb7a2a812d" + integrity sha512-VHZ8gX+EDfz+97jGcgyGCyRia/dPOd6Xh9yPv8Bl1+SoaIwD+a/vlrOmGRUyOYu7MwUhc7CxqeaDZU13S4+EpA== dependencies: - "@babel/code-frame" "^7.0.0" + "@babel/code-frame" "7.12.11" + "@eslint/eslintrc" "^0.4.3" + "@humanwhocodes/config-array" "^0.5.0" ajv "^6.10.0" chalk "^4.0.0" cross-spawn "^7.0.2" debug "^4.0.1" doctrine "^3.0.0" enquirer "^2.3.5" - eslint-scope "^5.1.0" + escape-string-regexp "^4.0.0" + eslint-scope "^5.1.1" eslint-utils "^2.1.0" - eslint-visitor-keys "^1.3.0" - espree "^7.2.0" - esquery "^1.2.0" + eslint-visitor-keys "^2.0.0" + espree "^7.3.1" + esquery "^1.4.0" esutils "^2.0.2" - file-entry-cache "^5.0.1" + fast-deep-equal "^3.1.3" + file-entry-cache "^6.0.1" functional-red-black-tree "^1.0.1" - glob-parent "^5.0.0" - globals "^12.1.0" + glob-parent "^5.1.2" + globals "^13.6.0" ignore "^4.0.6" import-fresh "^3.0.0" imurmurhash "^0.1.4" @@ -1557,7 +1695,7 @@ eslint@^7.7.0: js-yaml "^3.13.1" json-stable-stringify-without-jsonify "^1.0.1" levn "^0.4.1" - lodash "^4.17.19" + lodash.merge "^4.6.2" minimatch "^3.0.4" natural-compare "^1.4.0" optionator "^0.9.1" @@ -1566,17 +1704,17 @@ eslint@^7.7.0: semver "^7.2.1" strip-ansi "^6.0.0" strip-json-comments "^3.1.0" - table "^5.2.3" + table "^6.0.9" text-table "^0.2.0" v8-compile-cache "^2.0.3" -espree@^7.2.0: - version "7.3.0" - resolved "https://registry.yarnpkg.com/espree/-/espree-7.3.0.tgz#dc30437cf67947cf576121ebd780f15eeac72348" - integrity sha512-dksIWsvKCixn1yrEXO8UosNSxaDoSYpq9reEjZSbHLpT5hpaCAKTLBwq0RHtLrIr+c0ByiYzWT8KTMRzoRCNlw== +espree@^7.3.0, espree@^7.3.1: + version "7.3.1" + resolved "https://registry.yarnpkg.com/espree/-/espree-7.3.1.tgz#f2df330b752c6f55019f8bd89b7660039c1bbbb6" + integrity sha512-v3JCNCE64umkFpmkFGqzVKsOT0tN1Zr+ueqLZfpV1Ob8e+CEgPWa+OxCoGH3tnhimMKIaBm4m/vaRpJ/krRz2g== dependencies: acorn "^7.4.0" - acorn-jsx "^5.2.0" + acorn-jsx "^5.3.1" eslint-visitor-keys "^1.3.0" esprima@^4.0.0, esprima@^4.0.1: @@ -1584,29 +1722,29 @@ esprima@^4.0.0, esprima@^4.0.1: resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71" integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A== -esquery@^1.2.0: - version "1.3.1" - resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.3.1.tgz#b78b5828aa8e214e29fb74c4d5b752e1c033da57" - integrity sha512-olpvt9QG0vniUBZspVRN6lwB7hOZoTRtT+jzR+tS4ffYx2mzbw+z0XCOk44aaLYKApNX5nMm+E+P6o25ip/DHQ== +esquery@^1.4.0: + version "1.4.0" + resolved "https://registry.yarnpkg.com/esquery/-/esquery-1.4.0.tgz#2148ffc38b82e8c7057dfed48425b3e61f0f24a5" + integrity sha512-cCDispWt5vHHtwMY2YrAQ4ibFkAL8RbH5YGBnZBc90MolvvfkkQcJro/aZiAQUlQ3qgrYS6D6v8Gc5G5CQsc9w== dependencies: estraverse "^5.1.0" -esrecurse@^4.1.0: - version "4.2.1" - resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.2.1.tgz#007a3b9fdbc2b3bb87e4879ea19c92fdbd3942cf" - integrity sha512-64RBB++fIOAXPw3P9cy89qfMlvZEXZkqqJkjqqXIvzP5ezRZjW+lPWjw35UX/3EhUPFYbg5ER4JYgDw4007/DQ== +esrecurse@^4.3.0: + version "4.3.0" + resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.3.0.tgz#7ad7964d679abb28bee72cec63758b1c5d2c9921" + integrity sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag== dependencies: - estraverse "^4.1.0" + estraverse "^5.2.0" -estraverse@^4.1.0, estraverse@^4.1.1, estraverse@^4.2.0: +estraverse@^4.1.1, estraverse@^4.2.0: version "4.3.0" resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.3.0.tgz#398ad3f3c5a24948be7725e83d11a7de28cdbd1d" integrity sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw== -estraverse@^5.1.0: - version "5.2.0" - resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.2.0.tgz#307df42547e6cc7324d3cf03c155d5cdb8c53880" - integrity sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ== +estraverse@^5.1.0, estraverse@^5.2.0: + version "5.3.0" + resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123" + integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA== esutils@^2.0.2: version "2.0.3" @@ -1614,9 +1752,9 @@ esutils@^2.0.2: integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g== exec-sh@^0.3.2: - version "0.3.4" - resolved "https://registry.yarnpkg.com/exec-sh/-/exec-sh-0.3.4.tgz#3a018ceb526cc6f6df2bb504b2bfe8e3a4934ec5" - integrity sha512-sEFIkc61v75sWeOe72qyrqg2Qg0OuLESziUDk/O/z2qgS15y2gWVFrI6f2Qn/qw/0/NCfCEsmNA4zOjkwEZT1A== + version "0.3.6" + resolved "https://registry.yarnpkg.com/exec-sh/-/exec-sh-0.3.6.tgz#ff264f9e325519a60cb5e273692943483cca63bc" + integrity sha512-nQn+hI3yp+oD0huYhKwvYI32+JFeq+XkNcD1GAo3Y/MjxsfVGmrrzrnzjWiNY6f+pUCP440fThsFh5gZrRAU/w== execa@^1.0.0: version "1.0.0" @@ -1634,12 +1772,12 @@ execa@^1.0.0: exit@^0.1.2: version "0.1.2" resolved "https://registry.yarnpkg.com/exit/-/exit-0.1.2.tgz#0632638f8d877cc82107d30a0fff1a17cba1cd0c" - integrity sha1-BjJjj42HfMghB9MKD/8aF8uhzQw= + integrity sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ== expand-brackets@^2.1.4: version "2.1.4" resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-2.1.4.tgz#b77735e315ce30f6b6eff0f83b04151a22449622" - integrity sha1-t3c14xXOMPa27/D4OwQVGiJEliI= + integrity sha512-w/ozOKR9Obk3qoWeY/WDi6MFta9AoMR+zud60mdnbniMcBxRuFJyDt2LdX/14A1UABeqk+Uk+LDfUpvoGKppZA== dependencies: debug "^2.3.3" define-property "^0.2.5" @@ -1664,14 +1802,14 @@ expect@^24.9.0: extend-shallow@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-2.0.1.tgz#51af7d614ad9a9f610ea1bafbb989d6b1c56890f" - integrity sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8= + integrity sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug== dependencies: is-extendable "^0.1.0" extend-shallow@^3.0.0, extend-shallow@^3.0.2: version "3.0.2" resolved "https://registry.yarnpkg.com/extend-shallow/-/extend-shallow-3.0.2.tgz#26a71aaf073b39fb2127172746131c2704028db8" - integrity sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg= + integrity sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q== dependencies: assign-symbols "^1.0.0" is-extendable "^1.0.1" @@ -1698,14 +1836,14 @@ extglob@^2.0.4: extsprintf@1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.3.0.tgz#96918440e3041a7a414f8c52e3c574eb3c3e1e05" - integrity sha1-lpGEQOMEGnpBT4xS48V06zw+HgU= + integrity sha512-11Ndz7Nv+mvAC1j0ktTa7fAb0vLyGGX+rMHNBYQviQDGU0Hw7lhctJANqbPhu9nV9/izT/IntTgZ7Im/9LJs9g== extsprintf@^1.2.0: - version "1.4.0" - resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.0.tgz#e2689f8f356fad62cca65a3a91c5df5f9551692f" - integrity sha1-4mifjzVvrWLMplo6kcXfX5VRaS8= + version "1.4.1" + resolved "https://registry.yarnpkg.com/extsprintf/-/extsprintf-1.4.1.tgz#8d172c064867f235c0c84a596806d279bf4bcc07" + integrity sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA== -fast-deep-equal@^3.1.1: +fast-deep-equal@^3.1.1, fast-deep-equal@^3.1.3: version "3.1.3" resolved "https://registry.yarnpkg.com/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz#3a7d56b559d6cbc3eb512325244e619a65c6c525" integrity sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q== @@ -1718,28 +1856,28 @@ fast-json-stable-stringify@2.x, fast-json-stable-stringify@^2.0.0: fast-levenshtein@^2.0.6, fast-levenshtein@~2.0.6: version "2.0.6" resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917" - integrity sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc= + integrity sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw== fb-watchman@^2.0.0: - version "2.0.1" - resolved "https://registry.yarnpkg.com/fb-watchman/-/fb-watchman-2.0.1.tgz#fc84fb39d2709cf3ff6d743706157bb5708a8a85" - integrity sha512-DkPJKQeY6kKwmuMretBhr7G6Vodr7bFwDYTXIkfG1gjvNpaxBTQV3PbXg6bR1c1UP4jPOX0jHUbbHANL9vRjVg== + version "2.0.2" + resolved "https://registry.yarnpkg.com/fb-watchman/-/fb-watchman-2.0.2.tgz#e9524ee6b5c77e9e5001af0f85f3adbb8623255c" + integrity sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA== dependencies: bser "2.1.1" figures@^3.1.0: version "3.2.0" - resolved "http://registry.npm.dtstack.com/figures/-/figures-3.2.0.tgz#625c18bd293c604dc4a8ddb2febf0c88341746af" + resolved "https://registry.yarnpkg.com/figures/-/figures-3.2.0.tgz#625c18bd293c604dc4a8ddb2febf0c88341746af" integrity sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg== dependencies: escape-string-regexp "^1.0.5" -file-entry-cache@^5.0.1: - version "5.0.1" - resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-5.0.1.tgz#ca0f6efa6dd3d561333fb14515065c2fafdf439c" - integrity sha512-bCg29ictuBaKUwwArK4ouCaqDgLZcysCFLmM/Yn/FDoqndh/9vNuQfXRDvTuXKLxfD/JtZQGKFT8MGcJBK644g== +file-entry-cache@^6.0.1: + version "6.0.1" + resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-6.0.1.tgz#211b2dd9659cb0394b073e7323ac3c933d522027" + integrity sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg== dependencies: - flat-cache "^2.0.1" + flat-cache "^3.0.4" file-uri-to-path@1.0.0: version "1.0.0" @@ -1749,25 +1887,17 @@ file-uri-to-path@1.0.0: fill-range@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-4.0.0.tgz#d544811d428f98eb06a63dc402d2403c328c38f7" - integrity sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc= + integrity sha512-VcpLTWqWDiTerugjj8e3+esbg+skS3M9e54UuR3iCeIDMXCLTsAH8hTSzDQU/X6/6t3eYkOKoZSef2PlU6U1XQ== dependencies: extend-shallow "^2.0.1" is-number "^3.0.0" repeat-string "^1.6.1" to-regex-range "^2.1.0" -find-up@^1.0.0: - version "1.1.2" - resolved "http://registry.npm.dtstack.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f" - integrity sha1-ay6YIrGizgpgq2TWEOzK1TyyTQ8= - dependencies: - path-exists "^2.0.0" - pinkie-promise "^2.0.0" - find-up@^2.0.0: version "2.1.0" - resolved "http://registry.npm.dtstack.com/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7" - integrity sha1-RdG35QbHF93UgndaK3eSCjwMV6c= + resolved "https://registry.yarnpkg.com/find-up/-/find-up-2.1.0.tgz#45d1b7e506c717ddd482775a2b77920a3c0c57a7" + integrity sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ== dependencies: locate-path "^2.0.0" @@ -1780,7 +1910,7 @@ find-up@^3.0.0: find-up@^4.1.0: version "4.1.0" - resolved "http://registry.npm.dtstack.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19" + resolved "https://registry.yarnpkg.com/find-up/-/find-up-4.1.0.tgz#97afe7d6cdc0bc5928584b7c8d7b16e8a9aa5d19" integrity sha512-PpOwAdQ/YlXQ2vj8a3h8IipDuYRi3wceVQQGYWxNINccq40Anw7BlsEXCMbt1Zt+OLA6Fq9suIpIWD0OsnISlw== dependencies: locate-path "^5.0.0" @@ -1788,35 +1918,41 @@ find-up@^4.1.0: find-up@^5.0.0: version "5.0.0" - resolved "http://registry.npm.dtstack.com/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc" - integrity sha1-TJKBnstwg1YeT0okCoa+UZj1Nvw= + resolved "https://registry.yarnpkg.com/find-up/-/find-up-5.0.0.tgz#4c92819ecb7083561e4f4a240a86be5198f536fc" + integrity sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng== dependencies: locate-path "^6.0.0" path-exists "^4.0.0" -flat-cache@^2.0.1: - version "2.0.1" - resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-2.0.1.tgz#5d296d6f04bda44a4630a301413bdbc2ec085ec0" - integrity sha512-LoQe6yDuUMDzQAEH8sgmh4Md6oZnc/7PjtwjNFSzveXqSHt6ka9fPBuso7IGf9Rz4uqnSnWiFH2B/zj24a5ReA== +flat-cache@^3.0.4: + version "3.0.4" + resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-3.0.4.tgz#61b0338302b2fe9f957dcc32fc2a87f1c3048b11" + integrity sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg== dependencies: - flatted "^2.0.0" - rimraf "2.6.3" - write "1.0.3" + flatted "^3.1.0" + rimraf "^3.0.2" -flatted@^2.0.0: - version "2.0.2" - resolved "https://registry.yarnpkg.com/flatted/-/flatted-2.0.2.tgz#4575b21e2bcee7434aa9be662f4b7b5f9c2b5138" - integrity sha512-r5wGx7YeOwNWNlCA0wQ86zKyDLMQr+/RB8xy74M4hTphfmjlijTSSXGuH8rnvKZnfT9i+75zmd8jcKdMR4O6jA== +flatted@^3.1.0: + version "3.2.7" + resolved "https://registry.yarnpkg.com/flatted/-/flatted-3.2.7.tgz#609f39207cb614b89d0765b477cb2d437fbf9787" + integrity sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ== + +for-each@^0.3.3: + version "0.3.3" + resolved "https://registry.yarnpkg.com/for-each/-/for-each-0.3.3.tgz#69b447e88a0a5d32c3e7084f3f1710034b21376e" + integrity sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw== + dependencies: + is-callable "^1.1.3" for-in@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/for-in/-/for-in-1.0.2.tgz#81068d295a8142ec0ac726c6e2200c30fb6d5e80" - integrity sha1-gQaNKVqBQuwKxybG4iAMMPttXoA= + integrity sha512-7EwmXrOjyL+ChxMhmG5lnW9MPt1aIeZEwKhQzoBUdTV0N3zuwWDZYVJatDvZ2OyzPUvdIAZDsCetk3coyMfcnQ== forever-agent@~0.6.1: version "0.6.1" resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91" - integrity sha1-+8cfDEGt6zf5bFd60e1C2P2sypE= + integrity sha512-j0KLYPhm6zeac4lz3oJ3o65qvgQCcPubiyotZrXqEaG4hNagNYO8qdlUrX5vwqv9ohqeT/Z3j6+yW067yWWdUw== form-data@~2.3.2: version "2.3.3" @@ -1830,21 +1966,14 @@ form-data@~2.3.2: fragment-cache@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/fragment-cache/-/fragment-cache-0.2.1.tgz#4290fad27f13e89be7f33799c6bc5a0abfff0d19" - integrity sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk= + integrity sha512-GMBAbW9antB8iZRHLoGw0b3HANt57diZYFO/HL1JGIC1MjKrdmhxvrJbupnVvpys0zsz7yBApXdQyfepKly2kA== dependencies: map-cache "^0.2.2" -fs-access@^1.0.1: - version "1.0.1" - resolved "http://registry.npm.dtstack.com/fs-access/-/fs-access-1.0.1.tgz#d6a87f262271cefebec30c553407fb995da8777a" - integrity sha1-1qh/JiJxzv6+wwxVNAf7mV2od3o= - dependencies: - null-check "^1.0.0" - fs.realpath@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" - integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8= + integrity sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw== fsevents@^1.2.7: version "1.2.13" @@ -1859,36 +1988,54 @@ function-bind@^1.1.1: resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d" integrity sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A== +function.prototype.name@^1.1.5: + version "1.1.5" + resolved "https://registry.yarnpkg.com/function.prototype.name/-/function.prototype.name-1.1.5.tgz#cce0505fe1ffb80503e6f9e46cc64e46a12a9621" + integrity sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + es-abstract "^1.19.0" + functions-have-names "^1.2.2" + functional-red-black-tree@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz#1b0ab3bd553b2a0d6399d29c0e3ea0b252078327" - integrity sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc= + integrity sha512-dsKNQNdj6xA3T+QlADDA7mOSlX0qiMINjn0cgr+eGHGsbSHzTabcIogz2+p/iqP1Xs6EP/sS2SbqH+brGTbq0g== -gensync@^1.0.0-beta.1: - version "1.0.0-beta.1" - resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.1.tgz#58f4361ff987e5ff6e1e7a210827aa371eaac269" - integrity sha512-r8EC6NO1sngH/zdD9fiRDLdcgnbayXah+mLgManTaIZJqEC1MZstmnox8KpnI2/fxQwrp5OpCOYWLp4rBl4Jcg== +functions-have-names@^1.2.2: + version "1.2.3" + resolved "https://registry.yarnpkg.com/functions-have-names/-/functions-have-names-1.2.3.tgz#0404fe4ee2ba2f607f0e0ec3c80bae994133b834" + integrity sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ== -get-caller-file@^2.0.1: +gensync@^1.0.0-beta.2: + version "1.0.0-beta.2" + resolved "https://registry.yarnpkg.com/gensync/-/gensync-1.0.0-beta.2.tgz#32a6ee76c3d7f52d46b2b1ae5d93fea8580a25e0" + integrity sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg== + +get-caller-file@^2.0.1, get-caller-file@^2.0.5: version "2.0.5" resolved "https://registry.yarnpkg.com/get-caller-file/-/get-caller-file-2.0.5.tgz#4f94412a82db32f36e3b0b9741f8a97feb031f7e" integrity sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg== -get-pkg-repo@^1.0.0: - version "1.4.0" - resolved "http://registry.npm.dtstack.com/get-pkg-repo/-/get-pkg-repo-1.4.0.tgz#c73b489c06d80cc5536c2c853f9e05232056972d" - integrity sha1-xztInAbYDMVTbCyFP54FIyBWly0= +get-intrinsic@^1.0.2, get-intrinsic@^1.1.1, get-intrinsic@^1.1.3: + version "1.1.3" + resolved "https://registry.yarnpkg.com/get-intrinsic/-/get-intrinsic-1.1.3.tgz#063c84329ad93e83893c7f4f243ef63ffa351385" + integrity sha512-QJVz1Tj7MS099PevUG5jvnt9tSkXN8K14dxQlikJuPt4uD9hHAHjLyLBiLR5zELelBdD9QNRAXZzsJx0WaDL9A== dependencies: - hosted-git-info "^2.1.4" - meow "^3.3.0" - normalize-package-data "^2.3.0" - parse-github-repo-url "^1.3.0" - through2 "^2.0.0" + function-bind "^1.1.1" + has "^1.0.3" + has-symbols "^1.0.3" -get-stdin@^4.0.1: - version "4.0.1" - resolved "http://registry.npm.dtstack.com/get-stdin/-/get-stdin-4.0.1.tgz#b968c6b0a04384324902e8bf1a5df32579a450fe" - integrity sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4= +get-pkg-repo@^4.0.0: + version "4.2.1" + resolved "https://registry.yarnpkg.com/get-pkg-repo/-/get-pkg-repo-4.2.1.tgz#75973e1c8050c73f48190c52047c4cee3acbf385" + integrity sha512-2+QbHjFRfGB74v/pYWjd5OhU3TDIC2Gv/YKUTk/tCvAz0pkn/Mz6P3uByuBimLOcPvN2jYdScl3xGFSrx0jEcA== + dependencies: + "@hutson/parse-repository-url" "^3.0.0" + hosted-git-info "^4.0.0" + through2 "^2.0.0" + yargs "^16.2.0" get-stream@^4.0.0: version "4.1.0" @@ -1897,79 +2044,76 @@ get-stream@^4.0.0: dependencies: pump "^3.0.0" +get-symbol-description@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/get-symbol-description/-/get-symbol-description-1.0.0.tgz#7fdb81c900101fbd564dd5f1a30af5aadc1e58d6" + integrity sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw== + dependencies: + call-bind "^1.0.2" + get-intrinsic "^1.1.1" + get-value@^2.0.3, get-value@^2.0.6: version "2.0.6" resolved "https://registry.yarnpkg.com/get-value/-/get-value-2.0.6.tgz#dc15ca1c672387ca76bd37ac0a395ba2042a2c28" - integrity sha1-3BXKHGcjh8p2vTesCjlbogQqLCg= + integrity sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA== getpass@^0.1.1: version "0.1.7" resolved "https://registry.yarnpkg.com/getpass/-/getpass-0.1.7.tgz#5eff8e3e684d569ae4cb2b1282604e8ba62149fa" - integrity sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo= + integrity sha512-0fzj9JxOLfJ+XGLhR8ze3unN0KZCgZwiSSDz168VERjK8Wl8kVSdcu2kspd4s4wtAa1y/qrVRiAA0WclVsu0ng== dependencies: assert-plus "^1.0.0" -git-raw-commits@2.0.0: - version "2.0.0" - resolved "http://registry.npm.dtstack.com/git-raw-commits/-/git-raw-commits-2.0.0.tgz#d92addf74440c14bcc5c83ecce3fb7f8a79118b5" - integrity sha1-2Srd90RAwUvMXIPszj+3+KeRGLU= - dependencies: - dargs "^4.0.1" - lodash.template "^4.0.2" - meow "^4.0.0" - split2 "^2.0.0" - through2 "^2.0.0" - git-raw-commits@^2.0.8: - version "2.0.9" - resolved "http://registry.npm.dtstack.com/git-raw-commits/-/git-raw-commits-2.0.9.tgz#5cbc707a615cb77b71e687f8a1ee54af46208b22" - integrity sha1-XLxwemFct3tx5of4oe5Ur0YgiyI= + version "2.0.11" + resolved "https://registry.yarnpkg.com/git-raw-commits/-/git-raw-commits-2.0.11.tgz#bc3576638071d18655e1cc60d7f524920008d723" + integrity sha512-VnctFhw+xfj8Va1xtfEqCUD2XDrbAPSJx+hSrE5K7fGdjZruW7XV+QOrN7LF/RJyvspRiD2I0asWsxFp0ya26A== dependencies: dargs "^7.0.0" - lodash.template "^4.0.2" + lodash "^4.17.15" meow "^8.0.0" split2 "^3.0.0" through2 "^4.0.0" git-remote-origin-url@^2.0.0: version "2.0.0" - resolved "http://registry.npm.dtstack.com/git-remote-origin-url/-/git-remote-origin-url-2.0.0.tgz#5282659dae2107145a11126112ad3216ec5fa65f" - integrity sha1-UoJlna4hBxRaERJhEq0yFuxfpl8= + resolved "https://registry.yarnpkg.com/git-remote-origin-url/-/git-remote-origin-url-2.0.0.tgz#5282659dae2107145a11126112ad3216ec5fa65f" + integrity sha512-eU+GGrZgccNJcsDH5LkXR3PB9M958hxc7sbA8DFJjrv9j4L2P/eZfKhM+QD6wyzpiv+b1BpK0XrYCxkovtjSLw== dependencies: gitconfiglocal "^1.0.0" pify "^2.3.0" git-semver-tags@^4.0.0, git-semver-tags@^4.1.1: version "4.1.1" - resolved "http://registry.npm.dtstack.com/git-semver-tags/-/git-semver-tags-4.1.1.tgz#63191bcd809b0ec3e151ba4751c16c444e5b5780" - integrity sha1-YxkbzYCbDsPhUbpHUcFsRE5bV4A= + resolved "https://registry.yarnpkg.com/git-semver-tags/-/git-semver-tags-4.1.1.tgz#63191bcd809b0ec3e151ba4751c16c444e5b5780" + integrity sha512-OWyMt5zBe7xFs8vglMmhM9lRQzCWL3WjHtxNNfJTMngGym7pC1kh8sP6jevfydJ6LP3ZvGxfb6ABYgPUM0mtsA== dependencies: meow "^8.0.0" semver "^6.0.0" gitconfiglocal@^1.0.0: version "1.0.0" - resolved "http://registry.npm.dtstack.com/gitconfiglocal/-/gitconfiglocal-1.0.0.tgz#41d045f3851a5ea88f03f24ca1c6178114464b9b" - integrity sha1-QdBF84UaXqiPA/JMocYXgRRGS5s= + resolved "https://registry.yarnpkg.com/gitconfiglocal/-/gitconfiglocal-1.0.0.tgz#41d045f3851a5ea88f03f24ca1c6178114464b9b" + integrity sha512-spLUXeTAVHxDtKsJc8FkFVgFtMdEN9qPGpL23VfSHx4fP4+Ds097IXLvymbnDH8FnmxX5Nr9bPw3A+AQ6mWEaQ== dependencies: ini "^1.3.2" -glob-parent@^5.0.0: +glob-parent@^5.1.2: version "5.1.2" resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4" integrity sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow== dependencies: is-glob "^4.0.1" -glob@^7.0.0, glob@^7.1.1, glob@^7.1.2, glob@^7.1.3, glob@^7.1.6: - version "7.1.6" - resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6" - integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA== +glob@^7.1.1, glob@^7.1.2, glob@^7.1.3, glob@^7.1.6: + version "7.2.3" + resolved "https://registry.yarnpkg.com/glob/-/glob-7.2.3.tgz#b8df0fb802bbfa8e89bd1d938b4e16578ed44f2b" + integrity sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q== dependencies: fs.realpath "^1.0.0" inflight "^1.0.4" inherits "2" - minimatch "^3.0.4" + minimatch "^3.1.1" once "^1.3.0" path-is-absolute "^1.0.0" @@ -1978,24 +2122,31 @@ globals@^11.1.0: resolved "https://registry.yarnpkg.com/globals/-/globals-11.12.0.tgz#ab8795338868a0babd8525758018c2a7eb95c42e" integrity sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA== -globals@^12.1.0: - version "12.4.0" - resolved "https://registry.yarnpkg.com/globals/-/globals-12.4.0.tgz#a18813576a41b00a24a97e7f815918c2e19925f8" - integrity sha512-BWICuzzDvDoH54NHKCseDanAhE3CeDorgDL5MT6LMXXj2WCnd9UC2szdk4AWLfjdgNBCXLUanXYcpBBKOSWGwg== +globals@^13.6.0, globals@^13.9.0: + version "13.19.0" + resolved "https://registry.yarnpkg.com/globals/-/globals-13.19.0.tgz#7a42de8e6ad4f7242fbcca27ea5b23aca367b5c8" + integrity sha512-dkQ957uSRWHw7CFXLUtUHQI3g3aWApYhfNR2O6jn/907riyTYKVBmxYVROkBcY614FSSeSJh7Xm7SrUWCxvJMQ== dependencies: - type-fest "^0.8.1" + type-fest "^0.20.2" + +gopd@^1.0.1: + version "1.0.1" + resolved "https://registry.yarnpkg.com/gopd/-/gopd-1.0.1.tgz#29ff76de69dac7489b7c0918a5788e56477c332c" + integrity sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA== + dependencies: + get-intrinsic "^1.1.3" graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2: - version "4.2.4" - resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.4.tgz#2256bde14d3632958c465ebc96dc467ca07a29fb" - integrity sha512-WjKPNJF79dtJAVniUlGGWHYGz2jWxT6VhN/4m1NdkbZ2nOsEF+cI1Edgql5zCRhs/VsQYRvrXctxktVXZUkixw== + version "4.2.10" + resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.10.tgz#147d3a006da4ca3ce14728c7aefc287c367d7a6c" + integrity sha512-9ByhssR2fPVsNZj478qUUbKfmL0+t5BDVyjShtyZZLiK7ZDAArFFfopyOTj0M05wE2tJPisA4iTnnXl2YoPvOA== growly@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/growly/-/growly-1.3.0.tgz#f10748cbe76af964b7c96c93c6bcc28af120c081" - integrity sha1-8QdIy+dq+WS3yWyTxrzCivEgwIE= + integrity sha512-+xGQY0YyAWCnqy7Cd++hc2JqMYzlm0dG30Jd0beaA64sROr8C4nt8Yc9V5Ro3avlSUDTN0ulqP/VBKi1/lLygw== -handlebars@^4.7.6: +handlebars@^4.7.7: version "4.7.7" resolved "https://registry.yarnpkg.com/handlebars/-/handlebars-4.7.7.tgz#9ce33416aad02dbd6c8fafa8240d5d98004945a1" integrity sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA== @@ -2010,7 +2161,7 @@ handlebars@^4.7.6: har-schema@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/har-schema/-/har-schema-2.0.0.tgz#a94c2224ebcac04782a0d9035521f24735b7ec92" - integrity sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI= + integrity sha512-Oqluz6zhGX8cyRaTQlFMPw80bSJVG2x/cFb8ZPhUILGgHka9SsokCCOQgpveePerqidZOrT14ipqfJb7ILcW5Q== har-validator@~5.1.3: version "5.1.5" @@ -2022,28 +2173,47 @@ har-validator@~5.1.3: hard-rejection@^2.1.0: version "2.1.0" - resolved "http://registry.npm.dtstack.com/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883" - integrity sha1-HG7aXBaFxjlCdm15u0Cudzzs2IM= + resolved "https://registry.yarnpkg.com/hard-rejection/-/hard-rejection-2.1.0.tgz#1c6eda5c1685c63942766d79bb40ae773cecd883" + integrity sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA== + +has-bigints@^1.0.1, has-bigints@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/has-bigints/-/has-bigints-1.0.2.tgz#0871bd3e3d51626f6ca0966668ba35d5602d6eaa" + integrity sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ== has-flag@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd" - integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0= + integrity sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw== has-flag@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-4.0.0.tgz#944771fd9c81c81265c4d6941860da06bb59479b" integrity sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ== -has-symbols@^1.0.0, has-symbols@^1.0.1: - version "1.0.1" - resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.1.tgz#9f5214758a44196c406d9bd76cebf81ec2dd31e8" - integrity sha512-PLcsoqu++dmEIZB+6totNFKq/7Do+Z0u4oT0zKOJNl3lYK6vGwwu2hjHs+68OEZbTjiUE9bgOABXbP/GvrS0Kg== +has-property-descriptors@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/has-property-descriptors/-/has-property-descriptors-1.0.0.tgz#610708600606d36961ed04c196193b6a607fa861" + integrity sha512-62DVLZGoiEBDHQyqG4w9xCuZ7eJEwNmJRWw2VY84Oedb7WFcA27fiEVe8oUQx9hAUJ4ekurquucTGwsyO1XGdQ== + dependencies: + get-intrinsic "^1.1.1" + +has-symbols@^1.0.1, has-symbols@^1.0.2, has-symbols@^1.0.3: + version "1.0.3" + resolved "https://registry.yarnpkg.com/has-symbols/-/has-symbols-1.0.3.tgz#bb7b2c4349251dce87b125f7bdf874aa7c8b39f8" + integrity sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A== + +has-tostringtag@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/has-tostringtag/-/has-tostringtag-1.0.0.tgz#7e133818a7d394734f941e73c3d3f9291e658b25" + integrity sha512-kFjcSNhnlGV1kyoGk7OXKSawH5JOb/LzUc5w9B02hOTO0dfFRjbHQKvg1d6cf3HbeUmtU9VbbV3qzZ2Teh97WQ== + dependencies: + has-symbols "^1.0.2" has-value@^0.3.1: version "0.3.1" resolved "https://registry.yarnpkg.com/has-value/-/has-value-0.3.1.tgz#7b1f58bada62ca827ec0a2078025654845995e1f" - integrity sha1-ex9YutpiyoJ+wKIHgCVlSEWZXh8= + integrity sha512-gpG936j8/MzaeID5Yif+577c17TxaDmhuyVgSwtnL/q8UUTySg8Mecb+8Cf1otgLoD7DDH75axp86ER7LFsf3Q== dependencies: get-value "^2.0.3" has-values "^0.1.4" @@ -2052,7 +2222,7 @@ has-value@^0.3.1: has-value@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/has-value/-/has-value-1.0.0.tgz#18b281da585b1c5c51def24c930ed29a0be6b177" - integrity sha1-GLKB2lhbHFxR3vJMkw7SmgvmsXc= + integrity sha512-IBXk4GTsLYdQ7Rvt+GRBrFSVEkmuOUy4re0Xjd9kJSUQpnTrWR4/y9RpfexN9vkAPMFuQoeWKwqzPozRTlasGw== dependencies: get-value "^2.0.6" has-values "^1.0.0" @@ -2061,12 +2231,12 @@ has-value@^1.0.0: has-values@^0.1.4: version "0.1.4" resolved "https://registry.yarnpkg.com/has-values/-/has-values-0.1.4.tgz#6d61de95d91dfca9b9a02089ad384bff8f62b771" - integrity sha1-bWHeldkd/Km5oCCJrThL/49it3E= + integrity sha512-J8S0cEdWuQbqD9//tlZxiMuMNmxB8PlEwvYwuxsTmR1G5RXUePEX/SJn7aD0GMLieuZYSwNH0cQuJGwnYunXRQ== has-values@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/has-values/-/has-values-1.0.0.tgz#95b0b63fec2146619a6fe57fe75628d5a39efe4f" - integrity sha1-lbC2P+whRmGab+V/51Yo1aOe/k8= + integrity sha512-ODYZC64uqzmtfGMEAX/FvZiRyWLpAC3vYnNunURUnkGVTS+mI0smVsWaPydRBsE3g+ok7h960jChO8mFcWlHaQ== dependencies: is-number "^3.0.0" kind-of "^4.0.0" @@ -2083,10 +2253,10 @@ hosted-git-info@^2.1.4: resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.9.tgz#dffc0bf9a21c02209090f2aa69429e1414daf3f9" integrity sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw== -hosted-git-info@^3.0.6: - version "3.0.7" - resolved "http://registry.npm.dtstack.com/hosted-git-info/-/hosted-git-info-3.0.7.tgz#a30727385ea85acfcee94e0aad9e368c792e036c" - integrity sha1-owcnOF6oWs/O6U4KrZ42jHkuA2w= +hosted-git-info@^4.0.0, hosted-git-info@^4.0.1: + version "4.1.0" + resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-4.1.0.tgz#827b82867e9ff1c8d0c4d9d53880397d2c86d224" + integrity sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA== dependencies: lru-cache "^6.0.0" @@ -2105,7 +2275,7 @@ html-escaper@^2.0.0: http-signature@~1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/http-signature/-/http-signature-1.2.0.tgz#9aecd925114772f3d95b65a60abb8f7c18fbace1" - integrity sha1-muzZJRFHcvPZW2WmCruPfBj7rOE= + integrity sha512-CAbnr6Rz4CYQkLYUtSNXxQPUH2gK8f3iWexVlsnMeD+GjlsQ0Xsy1cOX+mN3dtxYomRy21CiOzU8Uhw6OwncEQ== dependencies: assert-plus "^1.0.0" jsprim "^1.2.2" @@ -2123,10 +2293,10 @@ ignore@^4.0.6: resolved "https://registry.yarnpkg.com/ignore/-/ignore-4.0.6.tgz#750e3db5862087b4737ebac8207ffd1ef27b25fc" integrity sha512-cyFDKrqc/YdcWFniJhzI42+AzS+gNwmUzOSFcRCQYwySuBBBy/KjuxWLZ/FHEH6Moq1NizMOBWyTcv8O4OZIMg== -import-fresh@^3.0.0: - version "3.2.1" - resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.2.1.tgz#633ff618506e793af5ac91bf48b72677e15cbe66" - integrity sha512-6e1q1cnWP2RXD9/keSkxHScg508CdXqXWgWBaETNhyuBFz+kUZlKboh+ISK+bU++DmbHimVBrOz/zzPe0sZ3sQ== +import-fresh@^3.0.0, import-fresh@^3.2.1: + version "3.3.0" + resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b" + integrity sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw== dependencies: parent-module "^1.0.0" resolve-from "^4.0.0" @@ -2142,29 +2312,17 @@ import-local@^2.0.0: imurmurhash@^0.1.4: version "0.1.4" resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea" - integrity sha1-khi5srkoojixPcT7a21XbyMUU+o= - -indent-string@^2.1.0: - version "2.1.0" - resolved "http://registry.npm.dtstack.com/indent-string/-/indent-string-2.1.0.tgz#8e2d48348742121b4a8218b7a137e9a52049dc80" - integrity sha1-ji1INIdCEhtKghi3oTfppSBJ3IA= - dependencies: - repeating "^2.0.0" - -indent-string@^3.0.0: - version "3.2.0" - resolved "http://registry.npm.dtstack.com/indent-string/-/indent-string-3.2.0.tgz#4a5fd6d27cc332f37e5419a504dbb837105c9289" - integrity sha1-Sl/W0nzDMvN+VBmlBNu4NxBckok= + integrity sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA== indent-string@^4.0.0: version "4.0.0" - resolved "http://registry.npm.dtstack.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251" - integrity sha1-Yk+PRJfWGbLZdoUx1Y9BIoVNclE= + resolved "https://registry.yarnpkg.com/indent-string/-/indent-string-4.0.0.tgz#624f8f4497d619b2d9768531d58f4122854d7251" + integrity sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg== inflight@^1.0.4: version "1.0.6" resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" - integrity sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk= + integrity sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA== dependencies: once "^1.3.0" wrappy "1" @@ -2176,13 +2334,17 @@ inherits@2, inherits@^2.0.3, inherits@~2.0.3: ini@^1.3.2: version "1.3.8" - resolved "http://registry.npm.dtstack.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c" - integrity sha1-op2kJbSIBvNHZ6Tvzjlyaa8oQyw= + resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.8.tgz#a29da425b48806f34767a4efce397269af28432c" + integrity sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew== -interpret@^1.0.0: - version "1.4.0" - resolved "http://registry.npm.dtstack.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e" - integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA== +internal-slot@^1.0.3: + version "1.0.4" + resolved "https://registry.yarnpkg.com/internal-slot/-/internal-slot-1.0.4.tgz#8551e7baf74a7a6ba5f749cfb16aa60722f0d6f3" + integrity sha512-tA8URYccNzMo94s5MQZgH8NB/XTa6HsOo0MLfXTKKEnHVVdegzaQoFZ7Jp44bdvLvY2waT5dc+j5ICEswhi7UQ== + dependencies: + get-intrinsic "^1.1.3" + has "^1.0.3" + side-channel "^1.0.4" invariant@^2.2.4: version "2.2.4" @@ -2194,7 +2356,7 @@ invariant@^2.2.4: is-accessor-descriptor@^0.1.6: version "0.1.6" resolved "https://registry.yarnpkg.com/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz#a9e12cb3ae8d876727eeef3843f8a0897b5c98d6" - integrity sha1-qeEss66Nh2cn7u84Q/igiXtcmNY= + integrity sha512-e1BM1qnDbMRG3ll2U9dSK0UMHuWOs3pY3AtcFsmvwPtKL3MML/Q86i+GilLfvqEs4GW+ExB91tQ3Ig9noDIZ+A== dependencies: kind-of "^3.0.2" @@ -2208,17 +2370,32 @@ is-accessor-descriptor@^1.0.0: is-arrayish@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d" - integrity sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0= + integrity sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg== + +is-bigint@^1.0.1: + version "1.0.4" + resolved "https://registry.yarnpkg.com/is-bigint/-/is-bigint-1.0.4.tgz#08147a1875bc2b32005d41ccd8291dffc6691df3" + integrity sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg== + dependencies: + has-bigints "^1.0.1" + +is-boolean-object@^1.1.0: + version "1.1.2" + resolved "https://registry.yarnpkg.com/is-boolean-object/-/is-boolean-object-1.1.2.tgz#5c6dc200246dd9321ae4b885a114bb1f75f63719" + integrity sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA== + dependencies: + call-bind "^1.0.2" + has-tostringtag "^1.0.0" is-buffer@^1.1.5: version "1.1.6" resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.6.tgz#efaa2ea9daa0d7ab2ea13a97b2b8ad51fefbe8be" integrity sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w== -is-callable@^1.1.4, is-callable@^1.2.0: - version "1.2.0" - resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.0.tgz#83336560b54a38e35e3a2df7afd0454d691468bb" - integrity sha512-pyVD9AaGLxtg6srb2Ng6ynWJqkHU9bEM087AKck0w8QwDarTfNcpIYoU8x8Hv2Icm8u6kFJM18Dag8lyqGkviw== +is-callable@^1.1.3, is-callable@^1.1.4, is-callable@^1.2.7: + version "1.2.7" + resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.2.7.tgz#3bc2a85ea742d9e36205dcacdd72ca1fdc51b055" + integrity sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA== is-ci@^2.0.0: version "2.0.0" @@ -2227,17 +2404,17 @@ is-ci@^2.0.0: dependencies: ci-info "^2.0.0" -is-core-module@^2.1.0: - version "2.2.0" - resolved "http://registry.npm.dtstack.com/is-core-module/-/is-core-module-2.2.0.tgz#97037ef3d52224d85163f5597b2b63d9afed981a" - integrity sha1-lwN+89UiJNhRY/VZeytj2a/tmBo= +is-core-module@^2.5.0, is-core-module@^2.9.0: + version "2.11.0" + resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.11.0.tgz#ad4cb3e3863e814523c96f3f58d26cc570ff0144" + integrity sha512-RRjxlvLDkD1YJwDbroBHMb+cukurkDWNyHx7D3oNB5x9rb5ogcksMC5wHCadcXoo67gVr/+3GFySh3134zi6rw== dependencies: has "^1.0.3" is-data-descriptor@^0.1.4: version "0.1.4" resolved "https://registry.yarnpkg.com/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz#0b5ee648388e2c860282e793f1856fec3f301b56" - integrity sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y= + integrity sha512-+w9D5ulSoBNlmw9OHn3U2v51SyoCd0he+bB3xMl62oijhrspxowjU+AIcDY0N3iEJbUEkB15IlMASQsxYigvXg== dependencies: kind-of "^3.0.2" @@ -2249,9 +2426,11 @@ is-data-descriptor@^1.0.0: kind-of "^6.0.0" is-date-object@^1.0.1: - version "1.0.2" - resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.2.tgz#bda736f2cd8fd06d32844e7743bfa7494c3bfd7e" - integrity sha512-USlDT524woQ08aoZFzh3/Z6ch9Y/EWXEHQ/AaRN0SkKq4t2Jw2R2339tSXmwuVoY7LLlBCbOIlx2myP/L5zk0g== + version "1.0.5" + resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.5.tgz#0841d5536e724c25597bf6ea62e1bd38298df31f" + integrity sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ== + dependencies: + has-tostringtag "^1.0.0" is-descriptor@^0.1.0: version "0.1.6" @@ -2274,7 +2453,7 @@ is-descriptor@^1.0.0, is-descriptor@^1.0.2: is-extendable@^0.1.0, is-extendable@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89" - integrity sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik= + integrity sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw== is-extendable@^1.0.1: version "1.0.1" @@ -2286,21 +2465,16 @@ is-extendable@^1.0.1: is-extglob@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-2.1.1.tgz#a88c02535791f02ed37c76a1b9ea9773c833f8c2" - integrity sha1-qIwCU1eR8C7TfHahueqXc8gz+MI= - -is-finite@^1.0.0: - version "1.1.0" - resolved "http://registry.npm.dtstack.com/is-finite/-/is-finite-1.1.0.tgz#904135c77fb42c0641d6aa1bcdbc4daa8da082f3" - integrity sha1-kEE1x3+0LAZB1qobzbxNqo2ggvM= + integrity sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ== is-fullwidth-code-point@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f" - integrity sha1-o7MKXE8ZkYMWeqq5O+764937ZU8= + integrity sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w== is-fullwidth-code-point@^3.0.0: version "3.0.0" - resolved "http://registry.npm.dtstack.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" + resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz#f116f8064fe90b3f7844a38997c0b75051269f1d" integrity sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg== is-generator-fn@^2.0.0: @@ -2309,28 +2483,40 @@ is-generator-fn@^2.0.0: integrity sha512-cTIB4yPYL/Grw0EaSzASzg6bBy9gqCofvWN8okThAYIxKJZC+udlRAmGbM0XLeniEJSs8uEgHPGuHSe1XsOLSQ== is-glob@^4.0.0, is-glob@^4.0.1: - version "4.0.1" - resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.1.tgz#7567dbe9f2f5e2467bc77ab83c4a29482407a5dc" - integrity sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg== + version "4.0.3" + resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-4.0.3.tgz#64f61e42cbbb2eec2071a9dac0b28ba1e65d5084" + integrity sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg== dependencies: is-extglob "^2.1.1" +is-negative-zero@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/is-negative-zero/-/is-negative-zero-2.0.2.tgz#7bf6f03a28003b8b3965de3ac26f664d765f3150" + integrity sha512-dqJvarLawXsFbNDeJW7zAz8ItJ9cd28YufuuFzh0G8pNHjJMnY08Dv7sYX2uF5UpQOwieAeOExEYAWWfu7ZZUA== + +is-number-object@^1.0.4: + version "1.0.7" + resolved "https://registry.yarnpkg.com/is-number-object/-/is-number-object-1.0.7.tgz#59d50ada4c45251784e9904f5246c742f07a42fc" + integrity sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ== + dependencies: + has-tostringtag "^1.0.0" + is-number@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/is-number/-/is-number-3.0.0.tgz#24fd6201a4782cf50561c810276afc7d12d71195" - integrity sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU= + integrity sha512-4cboCqIpliH+mAvFNegjZQ4kgKc3ZUhQVr3HvWbSh5q3WH2v82ct+T2Y1hdU5Gdtorx/cLifQjqCbL7bpznLTg== dependencies: kind-of "^3.0.2" is-obj@^2.0.0: version "2.0.0" - resolved "http://registry.npm.dtstack.com/is-obj/-/is-obj-2.0.0.tgz#473fb05d973705e3fd9620545018ca8e22ef4982" - integrity sha1-Rz+wXZc3BeP9liBUUBjKjiLvSYI= + resolved "https://registry.yarnpkg.com/is-obj/-/is-obj-2.0.0.tgz#473fb05d973705e3fd9620545018ca8e22ef4982" + integrity sha512-drqDG3cbczxxEJRoOXcOjtdp1J/lyp1mNn0xaznRs8+muBhgQcrnbspox5X5fOw0HnMnbfDzvnEMEtqDEJEo8w== is-plain-obj@^1.1.0: version "1.1.0" - resolved "http://registry.npm.dtstack.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e" - integrity sha1-caUMhCnfync8kqOQpKA7OfzVHT4= + resolved "https://registry.yarnpkg.com/is-plain-obj/-/is-plain-obj-1.1.0.tgz#71a50c8429dfca773c92a390a4a03b39fcd51d3e" + integrity sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg== is-plain-object@^2.0.3, is-plain-object@^2.0.4: version "2.0.4" @@ -2339,41 +2525,58 @@ is-plain-object@^2.0.3, is-plain-object@^2.0.4: dependencies: isobject "^3.0.1" -is-regex@^1.1.0: - version "1.1.1" - resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.1.tgz#c6f98aacc546f6cec5468a07b7b153ab564a57b9" - integrity sha512-1+QkEcxiLlB7VEyFtyBg94e08OAsvq7FUBgApTq/w2ymCLyKJgDPsybBENVtA7XCQEgEXxKPonG+mvYRxh/LIg== +is-regex@^1.1.4: + version "1.1.4" + resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.4.tgz#eef5663cd59fa4c0ae339505323df6854bb15958" + integrity sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg== dependencies: - has-symbols "^1.0.1" + call-bind "^1.0.2" + has-tostringtag "^1.0.0" + +is-shared-array-buffer@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/is-shared-array-buffer/-/is-shared-array-buffer-1.0.2.tgz#8f259c573b60b6a32d4058a1a07430c0a7344c79" + integrity sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA== + dependencies: + call-bind "^1.0.2" is-stream@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/is-stream/-/is-stream-1.1.0.tgz#12d4a3dd4e68e0b79ceb8dbc84173ae80d91ca44" - integrity sha1-EtSj3U5o4Lec6428hBc66A2RykQ= + integrity sha512-uQPm8kcs47jx38atAcWTVxyltQYoPT68y9aWYdV6yWXSyW8mzSat0TL6CiWdZeCdF3KrAvpVtnHbTv4RN+rqdQ== -is-symbol@^1.0.2: - version "1.0.3" - resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.3.tgz#38e1014b9e6329be0de9d24a414fd7441ec61937" - integrity sha512-OwijhaRSgqvhm/0ZdAcXNZt9lYdKFpcRDT5ULUuYXPoT794UNOdU+gpT6Rzo7b4V2HUl/op6GqY894AZwv9faQ== +is-string@^1.0.5, is-string@^1.0.7: + version "1.0.7" + resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.7.tgz#0dd12bf2006f255bb58f695110eff7491eebc0fd" + integrity sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg== dependencies: - has-symbols "^1.0.1" + has-tostringtag "^1.0.0" + +is-symbol@^1.0.2, is-symbol@^1.0.3: + version "1.0.4" + resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.4.tgz#a6dac93b635b063ca6872236de88910a57af139c" + integrity sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg== + dependencies: + has-symbols "^1.0.2" is-text-path@^1.0.1: version "1.0.1" - resolved "http://registry.npm.dtstack.com/is-text-path/-/is-text-path-1.0.1.tgz#4e1aa0fb51bfbcb3e92688001397202c1775b66e" - integrity sha1-Thqg+1G/vLPpJogAE5cgLBd1tm4= + resolved "https://registry.yarnpkg.com/is-text-path/-/is-text-path-1.0.1.tgz#4e1aa0fb51bfbcb3e92688001397202c1775b66e" + integrity sha512-xFuJpne9oFz5qDaodwmmG08e3CawH/2ZV8Qqza1Ko7Sk8POWbkRdwIoAWVhqvq0XeUzANEhKo2n0IXUGBm7A/w== dependencies: text-extensions "^1.0.0" is-typedarray@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-typedarray/-/is-typedarray-1.0.0.tgz#e479c80858df0c1b11ddda6940f96011fcda4a9a" - integrity sha1-5HnICFjfDBsR3dppQPlgEfzaSpo= + integrity sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA== -is-utf8@^0.2.0: - version "0.2.1" - resolved "http://registry.npm.dtstack.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72" - integrity sha1-Sw2hRCEE0bM2NA6AeX6GXPOffXI= +is-weakref@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/is-weakref/-/is-weakref-1.0.2.tgz#9529f383a9338205e89765e0392efc2f100f06f2" + integrity sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ== + dependencies: + call-bind "^1.0.2" is-windows@^1.0.2: version "1.0.2" @@ -2383,34 +2586,34 @@ is-windows@^1.0.2: is-wsl@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-1.1.0.tgz#1f16e4aa22b04d1336b66188a66af3c600c3a66d" - integrity sha1-HxbkqiKwTRM2tmGIpmrzxgDDpm0= + integrity sha512-gfygJYZ2gLTDlmbWMI0CE2MwnFzSN/2SZfkMlItC4K/JBlsWVDB0bO6XhqcY13YXE7iMcAJnzTCJjPiTeJJ0Mw== isarray@1.0.0, isarray@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11" - integrity sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE= + integrity sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ== isexe@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/isexe/-/isexe-2.0.0.tgz#e8fbf374dc556ff8947a10dcb0572d633f2cfa10" - integrity sha1-6PvzdNxVb/iUehDcsFctYz8s+hA= + integrity sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw== isobject@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89" - integrity sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk= + integrity sha512-+OUdGJlgjOBZDfxnDjYYG6zp487z0JGNQq3cYQYg5f5hKR+syHMsaztzGeml/4kGG55CSpKSpWTY+jYGgsHLgA== dependencies: isarray "1.0.0" isobject@^3.0.0, isobject@^3.0.1: version "3.0.1" resolved "https://registry.yarnpkg.com/isobject/-/isobject-3.0.1.tgz#4e431e92b11a9731636aa1f9c8d1ccbcfdab78df" - integrity sha1-TkMekrEalzFjaqH5yNHMvP2reN8= + integrity sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg== isstream@~0.1.2: version "0.1.2" resolved "https://registry.yarnpkg.com/isstream/-/isstream-0.1.2.tgz#47e63f7af55afa6f92e1500e690eb8b8529c099a" - integrity sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo= + integrity sha512-Yljz7ffyPbrLpLngrMtZ7NduUgVvi6wG9RJ9IUcyCd59YQ911PBJphODUcbOVbqYfxe1wuYf/LJ8PauMRwsM/g== istanbul-lib-coverage@^2.0.2, istanbul-lib-coverage@^2.0.5: version "2.0.5" @@ -2645,9 +2848,9 @@ jest-mock@^24.9.0: "@jest/types" "^24.9.0" jest-pnp-resolver@^1.2.1: - version "1.2.2" - resolved "https://registry.yarnpkg.com/jest-pnp-resolver/-/jest-pnp-resolver-1.2.2.tgz#b704ac0ae028a89108a4d040b3f919dfddc8e33c" - integrity sha512-olV41bKSMm8BdnuMsewT4jqlZ8+3TCARAXjZGT9jcoSnrfUnRCqnMoF9XEeoWjbzObpqF9dRhHQj0Xb9QdF6/w== + version "1.2.3" + resolved "https://registry.yarnpkg.com/jest-pnp-resolver/-/jest-pnp-resolver-1.2.3.tgz#930b1546164d4ad5937d5540e711d4d38d4cad2e" + integrity sha512-+3NpwQEnRoIBtx4fyhblQDPgJI0H1IEIkX7ShLUjPGA7TtUTvI1oiKi3SR4oBR0hQhQR80l4WAe5RrXBwWMA8w== jest-regex-util@^24.3.0, jest-regex-util@^24.9.0: version "24.9.0" @@ -2817,9 +3020,9 @@ jest@^24.8.0: integrity sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ== js-yaml@^3.13.1: - version "3.14.0" - resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.0.tgz#a7a34170f26a21bb162424d8adacb4113a69e482" - integrity sha512-/4IbIeHcD9VMHFqDR/gQ7EdZdLimOvW2DdcxFjdyyZ9NsbS+ccrXqVWDtab/lRl5AlUqmpBx8EhPaWR+OtY17A== + version "3.14.1" + resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.14.1.tgz#dae812fdb3825fa306609a8717383c50c36a0537" + integrity sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g== dependencies: argparse "^1.0.7" esprima "^4.0.0" @@ -2827,7 +3030,7 @@ js-yaml@^3.13.1: jsbn@~0.1.0: version "0.1.1" resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-0.1.1.tgz#a5e654c2e5a2deb5f201d96cefbca80c0ef2f513" - integrity sha1-peZUwuWi3rXyAdls77yoDA7y9RM= + integrity sha512-UVU9dibq2JcFWxQPA6KCqj5O42VOmAY3zQUfEKxU0KpTGXwNoCjkX1e13eHNvw/xPynt6pU0rZ1htjWTNTSXsg== jsdom@^11.5.1: version "11.12.0" @@ -2873,62 +3076,65 @@ json-parse-better-errors@^1.0.1: json-parse-even-better-errors@^2.3.0: version "2.3.1" - resolved "http://registry.npm.dtstack.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d" - integrity sha1-fEeAWpQxmSjgV3dAXcEuH3pO4C0= + resolved "https://registry.yarnpkg.com/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz#7c47805a94319928e05777405dc12e1f7a4ee02d" + integrity sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w== json-schema-traverse@^0.4.1: version "0.4.1" resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz#69f6a87d9513ab8bb8fe63bdb0979c448e684660" integrity sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg== -json-schema@0.2.3: - version "0.2.3" - resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.2.3.tgz#b480c892e59a2f05954ce727bd3f2a4e882f9e13" - integrity sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM= +json-schema-traverse@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz#ae7bcb3656ab77a73ba5c49bf654f38e6b6860e2" + integrity sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug== + +json-schema@0.4.0: + version "0.4.0" + resolved "https://registry.yarnpkg.com/json-schema/-/json-schema-0.4.0.tgz#f7de4cf6efab838ebaeb3236474cbba5a1930ab5" + integrity sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA== json-stable-stringify-without-jsonify@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz#9db7b59496ad3f3cfef30a75142d2d930ad72651" - integrity sha1-nbe1lJatPzz+8wp1FC0tkwrXJlE= + integrity sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw== json-stringify-safe@^5.0.1, json-stringify-safe@~5.0.1: version "5.0.1" resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb" - integrity sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus= + integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA== -json5@2.x, json5@^2.1.2: - version "2.1.3" - resolved "https://registry.yarnpkg.com/json5/-/json5-2.1.3.tgz#c9b0f7fa9233bfe5807fe66fcf3a5617ed597d43" - integrity sha512-KXPvOm8K9IJKFM0bmdn8QXh7udDh1g/giieX0NLCaMnb4hEiVFqnop2ImTXCc5e0/oHz3LTqmHGtExn5hfMkOA== - dependencies: - minimist "^1.2.5" +json5@2.x, json5@^2.2.1: + version "2.2.1" + resolved "https://registry.yarnpkg.com/json5/-/json5-2.2.1.tgz#655d50ed1e6f95ad1a3caababd2b0efda10b395c" + integrity sha512-1hqLFMSrGHRHxav9q9gNjJ5EXznIxGVO09xQRrwplcS8qs28pZ8s8hupZAmqDwZUmVZ2Qb2jnyPOWcDH8m8dlA== jsonparse@^1.2.0: version "1.3.1" - resolved "http://registry.npm.dtstack.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280" - integrity sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA= + resolved "https://registry.yarnpkg.com/jsonparse/-/jsonparse-1.3.1.tgz#3f4dae4a91fac315f71062f8521cc239f1366280" + integrity sha512-POQXvpdL69+CluYsillJ7SUhKvytYjW9vG/GKpnf+xP8UWgYEM/RaMzHHofbALDiKbbP1W8UEYmgGl39WkPZsg== jsprim@^1.2.2: - version "1.4.1" - resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.1.tgz#313e66bc1e5cc06e438bc1b7499c2e5c56acb6a2" - integrity sha1-MT5mvB5cwG5Di8G3SZwuXFastqI= + version "1.4.2" + resolved "https://registry.yarnpkg.com/jsprim/-/jsprim-1.4.2.tgz#712c65533a15c878ba59e9ed5f0e26d5b77c5feb" + integrity sha512-P2bSOMAc/ciLz6DzgjVlGJP9+BrJWu5UDGK70C2iweC5QBIeFf0ZXRvGjEj2uYgrY2MkAAhsSWHDWlFtEroZWw== dependencies: assert-plus "1.0.0" extsprintf "1.3.0" - json-schema "0.2.3" + json-schema "0.4.0" verror "1.10.0" kind-of@^3.0.2, kind-of@^3.0.3, kind-of@^3.2.0: version "3.2.2" resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.2.2.tgz#31ea21a734bab9bbb0f32466d893aea51e4a3c64" - integrity sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ= + integrity sha512-NOW9QQXMoZGg/oqnVNoNTTIFEIid1627WCffUBJEdMxYApq7mNE7CpzucIPc+ZQg25Phej7IJSmX3hO+oblOtQ== dependencies: is-buffer "^1.1.5" kind-of@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-4.0.0.tgz#20813df3d712928b207378691a45066fae72dd57" - integrity sha1-IIE989cSkosgc3hpGkUGb65y3Vc= + integrity sha512-24XsCxmEbRwEDbz/qz3stgin8TTzZ1ESR56OMCN0ujYg+vRutNSiOj9bHH9u85DKgXguraugV5sFuvbD4FW/hw== dependencies: is-buffer "^1.1.5" @@ -2968,31 +3174,20 @@ levn@^0.4.1: levn@~0.3.0: version "0.3.0" resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee" - integrity sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4= + integrity sha512-0OO4y2iOHix2W6ujICbKIaEQXvFQHue65vUG3pb5EUomzPI90z9hsA1VsO/dbIIpC53J8gxM9Q4Oho0jrCM/yA== dependencies: prelude-ls "~1.1.2" type-check "~0.3.2" lines-and-columns@^1.1.6: - version "1.1.6" - resolved "http://registry.npm.dtstack.com/lines-and-columns/-/lines-and-columns-1.1.6.tgz#1c00c743b433cd0a4e80758f7b64a57440d9ff00" - integrity sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA= - -load-json-file@^1.0.0: - version "1.1.0" - resolved "http://registry.npm.dtstack.com/load-json-file/-/load-json-file-1.1.0.tgz#956905708d58b4bab4c2261b04f59f31c99374c0" - integrity sha1-lWkFcI1YtLq0wiYbBPWfMcmTdMA= - dependencies: - graceful-fs "^4.1.2" - parse-json "^2.2.0" - pify "^2.0.0" - pinkie-promise "^2.0.0" - strip-bom "^2.0.0" + version "1.2.4" + resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.2.4.tgz#eca284f75d2965079309dc0ad9255abb2ebc1632" + integrity sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg== load-json-file@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/load-json-file/-/load-json-file-4.0.0.tgz#2f5f45ab91e33216234fd53adab668eb4ec0993b" - integrity sha1-L19Fq5HjMhYjT9U62rZo607AmTs= + integrity sha512-Kx8hMakjX03tiGTLAIdJ+lL0htKnXjEZN6hk/tozf/WOuYGdZBJrZ+rCJRbVCugsjB3jMLn9746NsQIf5VjBMw== dependencies: graceful-fs "^4.1.2" parse-json "^4.0.0" @@ -3001,8 +3196,8 @@ load-json-file@^4.0.0: locate-path@^2.0.0: version "2.0.0" - resolved "http://registry.npm.dtstack.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e" - integrity sha1-K1aLJl7slExtnA3pw9u7ygNUzY4= + resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-2.0.0.tgz#2b568b265eec944c6d9c0de9c3dbbbca0354cd8e" + integrity sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA== dependencies: p-locate "^2.0.0" path-exists "^3.0.0" @@ -3017,54 +3212,44 @@ locate-path@^3.0.0: locate-path@^5.0.0: version "5.0.0" - resolved "http://registry.npm.dtstack.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0" + resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-5.0.0.tgz#1afba396afd676a6d42504d0a67a3a7eb9f62aa0" integrity sha512-t7hw9pI+WvuwNJXwk5zVHpyhIqzg2qTlklJOf0mVxGSbe3Fp2VieZcduNYjaLDoy6p9uGpQEGWG87WpMKlNq8g== dependencies: p-locate "^4.1.0" locate-path@^6.0.0: version "6.0.0" - resolved "http://registry.npm.dtstack.com/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286" - integrity sha1-VTIeswn+u8WcSAHZMackUqaB0oY= + resolved "https://registry.yarnpkg.com/locate-path/-/locate-path-6.0.0.tgz#55321eb309febbc59c4801d931a72452a681d286" + integrity sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw== dependencies: p-locate "^5.0.0" -lodash._reinterpolate@^3.0.0: - version "3.0.0" - resolved "http://registry.npm.dtstack.com/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz#0ccf2d89166af03b3663c796538b75ac6e114d9d" - integrity sha1-DM8tiRZq8Ds2Y8eWU4t1rG4RTZ0= - lodash.ismatch@^4.4.0: version "4.4.0" - resolved "http://registry.npm.dtstack.com/lodash.ismatch/-/lodash.ismatch-4.4.0.tgz#756cb5150ca3ba6f11085a78849645f188f85f37" - integrity sha1-dWy1FQyjum8RCFp4hJZF8Yj4Xzc= + resolved "https://registry.yarnpkg.com/lodash.ismatch/-/lodash.ismatch-4.4.0.tgz#756cb5150ca3ba6f11085a78849645f188f85f37" + integrity sha512-fPMfXjGQEV9Xsq/8MTSgUf255gawYRbjwMyDbcvDhXgV7enSZA0hynz6vMPnpAb5iONEzBHBPsT+0zes5Z301g== lodash.memoize@4.x: version "4.1.2" resolved "https://registry.yarnpkg.com/lodash.memoize/-/lodash.memoize-4.1.2.tgz#bcc6c49a42a2840ed997f323eada5ecd182e0bfe" - integrity sha1-vMbEmkKihA7Zl/Mj6tpezRguC/4= + integrity sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag== + +lodash.merge@^4.6.2: + version "4.6.2" + resolved "https://registry.yarnpkg.com/lodash.merge/-/lodash.merge-4.6.2.tgz#558aa53b43b661e1925a0afdfa36a9a1085fe57a" + integrity sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ== lodash.sortby@^4.7.0: version "4.7.0" resolved "https://registry.yarnpkg.com/lodash.sortby/-/lodash.sortby-4.7.0.tgz#edd14c824e2cc9c1e0b0a1b42bb5210516a42438" - integrity sha1-7dFMgk4sycHgsKG0K7UhBRakJDg= + integrity sha512-HDWXG8isMntAyRF5vZ7xKuEvOhT4AhlRt/3czTSjvGUxjYCBVRQY48ViDHyfYz9VIoBkW4TMGQNapx+l3RUwdA== -lodash.template@^4.0.2: - version "4.5.0" - resolved "http://registry.npm.dtstack.com/lodash.template/-/lodash.template-4.5.0.tgz#f976195cf3f347d0d5f52483569fe8031ccce8ab" - integrity sha1-+XYZXPPzR9DV9SSDVp/oAxzM6Ks= - dependencies: - lodash._reinterpolate "^3.0.0" - lodash.templatesettings "^4.0.0" +lodash.truncate@^4.4.2: + version "4.4.2" + resolved "https://registry.yarnpkg.com/lodash.truncate/-/lodash.truncate-4.4.2.tgz#5a350da0b1113b837ecfffd5812cbe58d6eae193" + integrity sha512-jttmRe7bRse52OsWIMDLaXxWqRAmtIUccAQ3garviCqJjafXOfNMO0yMfNpdD6zbGaTU0P5Nz7e7gAT6cKmJRw== -lodash.templatesettings@^4.0.0: - version "4.2.0" - resolved "http://registry.npm.dtstack.com/lodash.templatesettings/-/lodash.templatesettings-4.2.0.tgz#e481310f049d3cf6d47e912ad09313b154f0fb33" - integrity sha1-5IExDwSdPPbUfpEq0JMTsVTw+zM= - dependencies: - lodash._reinterpolate "^3.0.0" - -lodash@^4.17.14, lodash@^4.17.15, lodash@^4.17.19: +lodash@^4.17.15, lodash@^4.17.19: version "4.17.21" resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.21.tgz#679591c564c3bffaae8454cf0b3df370c3d6911c" integrity sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg== @@ -3076,17 +3261,9 @@ loose-envify@^1.0.0: dependencies: js-tokens "^3.0.0 || ^4.0.0" -loud-rejection@^1.0.0: - version "1.6.0" - resolved "http://registry.npm.dtstack.com/loud-rejection/-/loud-rejection-1.6.0.tgz#5b46f80147edee578870f086d04821cf998e551f" - integrity sha1-W0b4AUft7leIcPCG0Eghz5mOVR8= - dependencies: - currently-unhandled "^0.4.1" - signal-exit "^3.0.0" - lru-cache@^6.0.0: version "6.0.0" - resolved "http://registry.npm.dtstack.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94" + resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94" integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA== dependencies: yallist "^4.0.0" @@ -3104,75 +3281,39 @@ make-error@1.x: resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2" integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw== -makeerror@1.0.x: - version "1.0.11" - resolved "https://registry.yarnpkg.com/makeerror/-/makeerror-1.0.11.tgz#e01a5c9109f2af79660e4e8b9587790184f5a96c" - integrity sha1-4BpckQnyr3lmDk6LlYd5AYT1qWw= +makeerror@1.0.12: + version "1.0.12" + resolved "https://registry.yarnpkg.com/makeerror/-/makeerror-1.0.12.tgz#3e5dd2079a82e812e983cc6610c4a2cb0eaa801a" + integrity sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg== dependencies: - tmpl "1.0.x" + tmpl "1.0.5" map-cache@^0.2.2: version "0.2.2" resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf" - integrity sha1-wyq9C9ZSXZsFFkW7TyasXcmKDb8= + integrity sha512-8y/eV9QQZCiyn1SprXSrCmqJN0yNRATe+PO8ztwqrvrbdRLA3eYJF0yaR0YayLWkMbsQSKWS9N2gPcGEc4UsZg== -map-obj@^1.0.0, map-obj@^1.0.1: +map-obj@^1.0.0: version "1.0.1" - resolved "http://registry.npm.dtstack.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d" - integrity sha1-2TPOuSBdgr3PSIb2dCvcK03qFG0= - -map-obj@^2.0.0: - version "2.0.0" - resolved "http://registry.npm.dtstack.com/map-obj/-/map-obj-2.0.0.tgz#a65cd29087a92598b8791257a523e021222ac1f9" - integrity sha1-plzSkIepJZi4eRJXpSPgISIqwfk= + resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-1.0.1.tgz#d933ceb9205d82bdcf4886f6742bdc2b4dea146d" + integrity sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg== map-obj@^4.0.0: - version "4.1.0" - resolved "http://registry.npm.dtstack.com/map-obj/-/map-obj-4.1.0.tgz#b91221b542734b9f14256c0132c897c5d7256fd5" - integrity sha1-uRIhtUJzS58UJWwBMsiXxdclb9U= + version "4.3.0" + resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.3.0.tgz#9304f906e93faae70880da102a9f1df0ea8bb05a" + integrity sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ== map-visit@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/map-visit/-/map-visit-1.0.0.tgz#ecdca8f13144e660f1b5bd41f12f3479d98dfb8f" - integrity sha1-7Nyo8TFE5mDxtb1B8S80edmN+48= + integrity sha512-4y7uGv8bd2WdM9vpQsiQNo41Ln1NvhvDRuVt0k2JZQ+ezN2uaQes7lZeZ+QQUHOLQAtDaBJ+7wCbi+ab/KFs+w== dependencies: object-visit "^1.0.0" -meow@^3.3.0: - version "3.7.0" - resolved "http://registry.npm.dtstack.com/meow/-/meow-3.7.0.tgz#72cb668b425228290abbfa856892587308a801fb" - integrity sha1-cstmi0JSKCkKu/qFaJJYcwioAfs= - dependencies: - camelcase-keys "^2.0.0" - decamelize "^1.1.2" - loud-rejection "^1.0.0" - map-obj "^1.0.1" - minimist "^1.1.3" - normalize-package-data "^2.3.4" - object-assign "^4.0.1" - read-pkg-up "^1.0.1" - redent "^1.0.0" - trim-newlines "^1.0.0" - -meow@^4.0.0: - version "4.0.1" - resolved "http://registry.npm.dtstack.com/meow/-/meow-4.0.1.tgz#d48598f6f4b1472f35bf6317a95945ace347f975" - integrity sha512-xcSBHD5Z86zaOc+781KrupuHAzeGXSLtiAOmBsiLDiPSaYSB6hdew2ng9EBAnZ62jagG9MHAOdxpDi/lWBFJ/A== - dependencies: - camelcase-keys "^4.0.0" - decamelize-keys "^1.0.0" - loud-rejection "^1.0.0" - minimist "^1.1.3" - minimist-options "^3.0.1" - normalize-package-data "^2.3.4" - read-pkg-up "^3.0.0" - redent "^2.0.0" - trim-newlines "^2.0.0" - meow@^8.0.0: - version "8.1.0" - resolved "http://registry.npm.dtstack.com/meow/-/meow-8.1.0.tgz#0fcaa267e35e4d58584b8205923df6021ddcc7ba" - integrity sha1-D8qiZ+NeTVhYS4IFkj32Ah3cx7o= + version "8.1.2" + resolved "https://registry.yarnpkg.com/meow/-/meow-8.1.2.tgz#bcbe45bda0ee1729d350c03cffc8395a36c4e897" + integrity sha512-r85E3NdZ+mpYk1C6RjPFEMSE+s1iZMuHtsHAqY0DT3jZczl0diWUZ8g6oU7h0M9cD2EL+PzaYghhCLzR0ZNn5Q== dependencies: "@types/minimist" "^1.2.0" camelcase-keys "^6.2.2" @@ -3210,51 +3351,43 @@ micromatch@^3.1.10, micromatch@^3.1.4: snapdragon "^0.8.1" to-regex "^3.0.2" -mime-db@1.44.0: - version "1.44.0" - resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.44.0.tgz#fa11c5eb0aca1334b4233cb4d52f10c5a6272f92" - integrity sha512-/NOTfLrsPBVeH7YtFPgsVWveuL+4SjjYxaQ1xtM1KMFj7HdxlBlxeyNLzhyJVx7r4rZGJAZ/6lkKCitSc/Nmpg== +mime-db@1.52.0: + version "1.52.0" + resolved "https://registry.yarnpkg.com/mime-db/-/mime-db-1.52.0.tgz#bbabcdc02859f4987301c856e3387ce5ec43bf70" + integrity sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg== mime-types@^2.1.12, mime-types@~2.1.19: - version "2.1.27" - resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.27.tgz#47949f98e279ea53119f5722e0f34e529bec009f" - integrity sha512-JIhqnCasI9yD+SsmkquHBxTSEuZdQX5BuQnS2Vc7puQQQ+8yiP5AY5uWhpdv4YL4VM5c6iliiYWPgJ/nJQLp7w== + version "2.1.35" + resolved "https://registry.yarnpkg.com/mime-types/-/mime-types-2.1.35.tgz#381a871b62a734450660ae3deee44813f70d959a" + integrity sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw== dependencies: - mime-db "1.44.0" + mime-db "1.52.0" min-indent@^1.0.0: version "1.0.1" - resolved "http://registry.npm.dtstack.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869" - integrity sha1-pj9oFnOzBXH76LwlaGrnRu76mGk= + resolved "https://registry.yarnpkg.com/min-indent/-/min-indent-1.0.1.tgz#a63f681673b30571fbe8bc25686ae746eefa9869" + integrity sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg== -minimatch@^3.0.4: - version "3.0.4" - resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083" - integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA== +minimatch@^3.0.4, minimatch@^3.1.1: + version "3.1.2" + resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.1.2.tgz#19cd194bfd3e428f049a70817c038d89ab4be35b" + integrity sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw== dependencies: brace-expansion "^1.1.7" minimist-options@4.1.0: version "4.1.0" - resolved "http://registry.npm.dtstack.com/minimist-options/-/minimist-options-4.1.0.tgz#c0655713c53a8a2ebd77ffa247d342c40f010619" - integrity sha1-wGVXE8U6ii69d/+iR9NCxA8BBhk= + resolved "https://registry.yarnpkg.com/minimist-options/-/minimist-options-4.1.0.tgz#c0655713c53a8a2ebd77ffa247d342c40f010619" + integrity sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A== dependencies: arrify "^1.0.1" is-plain-obj "^1.1.0" kind-of "^6.0.3" -minimist-options@^3.0.1: - version "3.0.2" - resolved "http://registry.npm.dtstack.com/minimist-options/-/minimist-options-3.0.2.tgz#fba4c8191339e13ecf4d61beb03f070103f3d954" - integrity sha1-+6TIGRM54T7PTWG+sD8HAQPz2VQ= - dependencies: - arrify "^1.0.1" - is-plain-obj "^1.1.0" - -minimist@^1.1.1, minimist@^1.1.3, minimist@^1.2.0, minimist@^1.2.5: - version "1.2.5" - resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602" - integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw== +minimist@^1.1.1, minimist@^1.2.0, minimist@^1.2.5, minimist@^1.2.6: + version "1.2.7" + resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.7.tgz#daa1c4d91f507390437c6a8bc01078e7000c4d18" + integrity sha512-bzfL1YUZsP41gmu/qjrEk0Q6i2ix/cVeAhbCbqH9u3zYutS1cLg00qhrD0M2MVdCcx4Sc0UpP2eBWo9rotpq6g== mixin-deep@^1.2.0: version "1.3.2" @@ -3265,31 +3398,31 @@ mixin-deep@^1.2.0: is-extendable "^1.0.1" mkdirp@0.x, mkdirp@^0.5.1: - version "0.5.5" - resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def" - integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ== + version "0.5.6" + resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.6.tgz#7def03d2432dcae4ba1d611445c48396062255f6" + integrity sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw== dependencies: - minimist "^1.2.5" + minimist "^1.2.6" modify-values@^1.0.0: version "1.0.1" - resolved "http://registry.npm.dtstack.com/modify-values/-/modify-values-1.0.1.tgz#b3939fa605546474e3e3e3c63d64bd43b4ee6022" - integrity sha1-s5OfpgVUZHTj4+PGPWS9Q7TuYCI= + resolved "https://registry.yarnpkg.com/modify-values/-/modify-values-1.0.1.tgz#b3939fa605546474e3e3e3c63d64bd43b4ee6022" + integrity sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw== ms@2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/ms/-/ms-2.0.0.tgz#5608aeadfc00be6c2901df5f9861788de0d597c8" - integrity sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g= + integrity sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A== -ms@^2.1.1: +ms@2.1.2: version "2.1.2" resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009" integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w== nan@^2.12.1: - version "2.14.1" - resolved "https://registry.yarnpkg.com/nan/-/nan-2.14.1.tgz#d7be34dfa3105b91494c3147089315eff8874b01" - integrity sha512-isWHgVjnFjh2x2yuJ/tj3JbwoHu3UC2dX5G/88Cm24yB6YopVgxvBObDY7n5xW6ExmFhJpSEQqFPvq9zaXc8Jw== + version "2.17.0" + resolved "https://registry.yarnpkg.com/nan/-/nan-2.17.0.tgz#c0150a2368a182f033e9aa5195ec76ea41a199cb" + integrity sha512-2ZTgtl0nJsO0KQCjEpxcIr5D+Yv90plTitZt9JBfQvVJDS5seMl3FOvsh3+9CoYWXf/1l5OaZzzF6nDm4cagaQ== nanomatch@^1.2.9: version "1.2.13" @@ -3311,7 +3444,7 @@ nanomatch@^1.2.9: natural-compare@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7" - integrity sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc= + integrity sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw== neo-async@^2.6.0: version "2.6.2" @@ -3326,17 +3459,12 @@ nice-try@^1.0.4: node-int64@^0.4.0: version "0.4.0" resolved "https://registry.yarnpkg.com/node-int64/-/node-int64-0.4.0.tgz#87a9065cdb355d3182d8f94ce11188b825c68a3b" - integrity sha1-h6kGXNs1XTGC2PlM4RGIuCXGijs= - -node-modules-regexp@^1.0.0: - version "1.0.0" - resolved "https://registry.yarnpkg.com/node-modules-regexp/-/node-modules-regexp-1.0.0.tgz#8d9dbe28964a4ac5712e9131642107c71e90ec40" - integrity sha1-jZ2+KJZKSsVxLpExZCEHxx6Q7EA= + integrity sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw== node-notifier@^5.4.2: - version "5.4.3" - resolved "https://registry.yarnpkg.com/node-notifier/-/node-notifier-5.4.3.tgz#cb72daf94c93904098e28b9c590fd866e464bd50" - integrity sha512-M4UBGcs4jeOK9CjTsYwkvH6/MzuUmGCyTW+kCY7uO+1ZVr0+FHGdPdIf5CCLqAaxnRrWidyoQlNkMIIVwbKB8Q== + version "5.4.5" + resolved "https://registry.yarnpkg.com/node-notifier/-/node-notifier-5.4.5.tgz#0cbc1a2b0f658493b4025775a13ad938e96091ef" + integrity sha512-tVbHs7DyTLtzOiN78izLA85zRqB9NvEXkAf014Vx3jtSvn/xBl6bR8ZYifj+dFcFrKI21huSQgJZ6ZtL3B4HfQ== dependencies: growly "^1.3.0" is-wsl "^1.1.0" @@ -3344,7 +3472,12 @@ node-notifier@^5.4.2: shellwords "^0.1.1" which "^1.3.0" -normalize-package-data@^2.3.0, normalize-package-data@^2.3.2, normalize-package-data@^2.3.4, normalize-package-data@^2.5.0: +node-releases@^2.0.6: + version "2.0.7" + resolved "https://registry.yarnpkg.com/node-releases/-/node-releases-2.0.7.tgz#593edbc7c22860ee4d32d3933cfebdfab0c0e0e5" + integrity sha512-EJ3rzxL9pTWPjk5arA0s0dgXpnyiAbJDE6wHT62g7VsgrgQgmmZ+Ru++M1BFofncWja+Pnn3rEr3fieRySAdKQ== + +normalize-package-data@^2.3.2, normalize-package-data@^2.5.0: version "2.5.0" resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-2.5.0.tgz#e66db1838b200c1dfc233225d12cb36520e234a8" integrity sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA== @@ -3355,69 +3488,54 @@ normalize-package-data@^2.3.0, normalize-package-data@^2.3.2, normalize-package- validate-npm-package-license "^3.0.1" normalize-package-data@^3.0.0: - version "3.0.0" - resolved "http://registry.npm.dtstack.com/normalize-package-data/-/normalize-package-data-3.0.0.tgz#1f8a7c423b3d2e85eb36985eaf81de381d01301a" - integrity sha1-H4p8Qjs9LoXrNpher4HeOB0BMBo= + version "3.0.3" + resolved "https://registry.yarnpkg.com/normalize-package-data/-/normalize-package-data-3.0.3.tgz#dbcc3e2da59509a0983422884cd172eefdfa525e" + integrity sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA== dependencies: - hosted-git-info "^3.0.6" - resolve "^1.17.0" - semver "^7.3.2" + hosted-git-info "^4.0.1" + is-core-module "^2.5.0" + semver "^7.3.4" validate-npm-package-license "^3.0.1" normalize-path@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.1.1.tgz#1ab28b556e198363a8c1a6f7e6fa20137fe6aed9" - integrity sha1-GrKLVW4Zg2Oowab35vogE3/mrtk= + integrity sha512-3pKJwH184Xo/lnH6oyP1q2pMd7HcypqqmRs91/6/i2CGtWwIKGCkOOMTm/zXbgTEWHw1uNpNi/igc3ePOYHb6w== dependencies: remove-trailing-separator "^1.0.1" npm-run-path@^2.0.0: version "2.0.2" resolved "https://registry.yarnpkg.com/npm-run-path/-/npm-run-path-2.0.2.tgz#35a9232dfa35d7067b4cb2ddf2357b1871536c5f" - integrity sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8= + integrity sha512-lJxZYlT4DW/bRUtFh1MQIWqmLwQfAxnqWG4HhEdjMlkrJYnJn0Jrr2u3mgxqaWsdiBc76TYkTG/mhrnYTuzfHw== dependencies: path-key "^2.0.0" -null-check@^1.0.0: - version "1.0.0" - resolved "http://registry.npm.dtstack.com/null-check/-/null-check-1.0.0.tgz#977dffd7176012b9ec30d2a39db5cf72a0439edd" - integrity sha1-l33/1xdgErnsMNKjnbXPcqBDnt0= - -number-is-nan@^1.0.0: - version "1.0.1" - resolved "http://registry.npm.dtstack.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d" - integrity sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0= - nwsapi@^2.0.7: - version "2.2.0" - resolved "https://registry.yarnpkg.com/nwsapi/-/nwsapi-2.2.0.tgz#204879a9e3d068ff2a55139c2c772780681a38b7" - integrity sha512-h2AatdwYH+JHiZpv7pt/gSX1XoRGb7L/qSIeuqA6GwYoF9w1vP1cw42TO0aI2pNyshRK5893hNSl+1//vHK7hQ== + version "2.2.2" + resolved "https://registry.yarnpkg.com/nwsapi/-/nwsapi-2.2.2.tgz#e5418863e7905df67d51ec95938d67bf801f0bb0" + integrity sha512-90yv+6538zuvUMnN+zCr8LuV6bPFdq50304114vJYJ8RDyK8D5O9Phpbd6SZWgI7PwzmmfN1upeOJlvybDSgCw== oauth-sign@~0.9.0: version "0.9.0" resolved "https://registry.yarnpkg.com/oauth-sign/-/oauth-sign-0.9.0.tgz#47a7b016baa68b5fa0ecf3dee08a85c679ac6455" integrity sha512-fexhUFFPTGV8ybAtSIGbV6gOkSv8UtRbDBnAyLQw4QPKkgNlsH2ByPGtMUqdWkos6YCRmAqViwgZrJc/mRDzZQ== -object-assign@^4.0.1: - version "4.1.1" - resolved "http://registry.npm.dtstack.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863" - integrity sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM= - object-copy@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/object-copy/-/object-copy-0.1.0.tgz#7e7d858b781bd7c991a41ba975ed3812754e998c" - integrity sha1-fn2Fi3gb18mRpBupde04EnVOmYw= + integrity sha512-79LYn6VAb63zgtmAteVOWo9Vdj71ZVBy3Pbse+VqxDpEP83XuujMrGqHIwAXJ5I/aM0zU7dIyIAhifVTPrNItQ== dependencies: copy-descriptor "^0.1.0" define-property "^0.2.5" kind-of "^3.0.3" -object-inspect@^1.7.0: - version "1.8.0" - resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.8.0.tgz#df807e5ecf53a609cc6bfe93eac3cc7be5b3a9d0" - integrity sha512-jLdtEOB112fORuypAyl/50VRVIBIdVQOSUUGQHzJ4xBSbit81zRarz7GThkEFZy1RceYrWYcPcBFPQwHyAc1gA== +object-inspect@^1.12.2, object-inspect@^1.9.0: + version "1.12.2" + resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.12.2.tgz#c0641f26394532f28ab8d796ab954e43c009a8ea" + integrity sha512-z+cPxW0QGUp0mcqcsgQyLVRDoXFQbXOwBaqyF7VIgI4TWNQsDHrBpUQslRmIfAoYWdYzs6UlKJtB2XJpTaNSpQ== -object-keys@^1.0.11, object-keys@^1.0.12, object-keys@^1.1.1: +object-keys@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.1.1.tgz#1c47f272df277f3b1daf061677d9c82e2322c60e" integrity sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA== @@ -3425,39 +3543,41 @@ object-keys@^1.0.11, object-keys@^1.0.12, object-keys@^1.1.1: object-visit@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/object-visit/-/object-visit-1.0.1.tgz#f79c4493af0c5377b59fe39d395e41042dd045bb" - integrity sha1-95xEk68MU3e1n+OdOV5BBC3QRbs= + integrity sha512-GBaMwwAVK9qbQN3Scdo0OyvgPW7l3lnaVMj84uTOZlswkX0KpF6fyDBJhtTthf7pymztoN36/KEr1DyhF96zEA== dependencies: isobject "^3.0.0" -object.assign@^4.1.0: - version "4.1.0" - resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.0.tgz#968bf1100d7956bb3ca086f006f846b3bc4008da" - integrity sha512-exHJeq6kBKj58mqGyTQ9DFvrZC/eR6OwxzoM9YRoGBqrXYonaFyGiFMuc9VZrXf7DarreEwMpurG3dd+CNyW5w== +object.assign@^4.1.4: + version "4.1.4" + resolved "https://registry.yarnpkg.com/object.assign/-/object.assign-4.1.4.tgz#9673c7c7c351ab8c4d0b516f4343ebf4dfb7799f" + integrity sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ== dependencies: - define-properties "^1.1.2" - function-bind "^1.1.1" - has-symbols "^1.0.0" - object-keys "^1.0.11" + call-bind "^1.0.2" + define-properties "^1.1.4" + has-symbols "^1.0.3" + object-keys "^1.1.1" -object.getownpropertydescriptors@^2.1.0: - version "2.1.0" - resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.0.tgz#369bf1f9592d8ab89d712dced5cb81c7c5352649" - integrity sha512-Z53Oah9A3TdLoblT7VKJaTDdXdT+lQO+cNpKVnya5JDe9uLvzu1YyY1yFDFrcxrlRgWrEFH0jJtD/IbuwjcEVg== +object.getownpropertydescriptors@^2.1.1: + version "2.1.5" + resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.5.tgz#db5a9002489b64eef903df81d6623c07e5b4b4d3" + integrity sha512-yDNzckpM6ntyQiGTik1fKV1DcVDRS+w8bvpWNCBanvH5LfRX9O8WTHqQzG4RZwRAM4I0oU7TV11Lj5v0g20ibw== dependencies: - define-properties "^1.1.3" - es-abstract "^1.17.0-next.1" + array.prototype.reduce "^1.0.5" + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" object.pick@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/object.pick/-/object.pick-1.3.0.tgz#87a10ac4c1694bd2e1cbf53591a66141fb5dd747" - integrity sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c= + integrity sha512-tqa/UMy/CCoYmj+H5qc07qvSL9dqcs/WZENZ1JbtWBlATP+iVOe778gE6MSijnyCnORzDuX6hU+LA4SZ09YjFQ== dependencies: isobject "^3.0.1" once@^1.3.0, once@^1.3.1, once@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" - integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E= + integrity sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w== dependencies: wrappy "1" @@ -3488,18 +3608,18 @@ optionator@^0.9.1: p-each-series@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/p-each-series/-/p-each-series-1.0.0.tgz#930f3d12dd1f50e7434457a22cd6f04ac6ad7f71" - integrity sha1-kw89Et0fUOdDRFeiLNbwSsatf3E= + integrity sha512-J/e9xiZZQNrt+958FFzJ+auItsBGq+UrQ7nE89AUP7UOTtjHnkISANXLdayhVzh538UnLMCSlf13lFfRIAKQOA== dependencies: p-reduce "^1.0.0" p-finally@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/p-finally/-/p-finally-1.0.0.tgz#3fbcfb15b899a44123b34b6dcc18b724336a2cae" - integrity sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4= + integrity sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow== p-limit@^1.1.0: version "1.3.0" - resolved "http://registry.npm.dtstack.com/p-limit/-/p-limit-1.3.0.tgz#b86bd5f0c25690911c7590fcbfc2010d54b3ccb8" + resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-1.3.0.tgz#b86bd5f0c25690911c7590fcbfc2010d54b3ccb8" integrity sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q== dependencies: p-try "^1.0.0" @@ -3513,15 +3633,15 @@ p-limit@^2.0.0, p-limit@^2.2.0: p-limit@^3.0.2: version "3.1.0" - resolved "http://registry.npm.dtstack.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b" - integrity sha1-4drMvnjQ0TiMoYxk/qOOPlfjcGs= + resolved "https://registry.yarnpkg.com/p-limit/-/p-limit-3.1.0.tgz#e1daccbe78d0d1388ca18c64fea38e3e57e3706b" + integrity sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ== dependencies: yocto-queue "^0.1.0" p-locate@^2.0.0: version "2.0.0" - resolved "http://registry.npm.dtstack.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43" - integrity sha1-IKAQOyIqcMj9OcwuWAaA893l7EM= + resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-2.0.0.tgz#20a0103b222a70c8fd39cc2e580680f3dde5ec43" + integrity sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg== dependencies: p-limit "^1.1.0" @@ -3534,27 +3654,27 @@ p-locate@^3.0.0: p-locate@^4.1.0: version "4.1.0" - resolved "http://registry.npm.dtstack.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07" + resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-4.1.0.tgz#a3428bb7088b3a60292f66919278b7c297ad4f07" integrity sha512-R79ZZ/0wAxKGu3oYMlz8jy/kbhsNrS7SKZ7PxEHBgJ5+F2mtFW2fK2cOtBh1cHYkQsbzFV7I+EoRKe6Yt0oK7A== dependencies: p-limit "^2.2.0" p-locate@^5.0.0: version "5.0.0" - resolved "http://registry.npm.dtstack.com/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834" - integrity sha1-g8gxXGeFAF470CGDlBHJ4RDm2DQ= + resolved "https://registry.yarnpkg.com/p-locate/-/p-locate-5.0.0.tgz#83c8315c6785005e3bd021839411c9e110e6d834" + integrity sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw== dependencies: p-limit "^3.0.2" p-reduce@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/p-reduce/-/p-reduce-1.0.0.tgz#18c2b0dd936a4690a529f8231f58a0fdb6a47dfa" - integrity sha1-GMKw3ZNqRpClKfgjH1ig/bakffo= + integrity sha512-3Tx1T3oM1xO/Y8Gj0sWyE78EIJZ+t+aEmXUdvQgvGmSMri7aPTHoovbXEreWKkL5j21Er60XAWLTzKbAKYOujQ== p-try@^1.0.0: version "1.0.0" - resolved "http://registry.npm.dtstack.com/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3" - integrity sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M= + resolved "https://registry.yarnpkg.com/p-try/-/p-try-1.0.0.tgz#cbc79cdbaf8fd4228e13f621f2b1a237c1b207b3" + integrity sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww== p-try@^2.0.0: version "2.2.0" @@ -3568,30 +3688,18 @@ parent-module@^1.0.0: dependencies: callsites "^3.0.0" -parse-github-repo-url@^1.3.0: - version "1.4.1" - resolved "http://registry.npm.dtstack.com/parse-github-repo-url/-/parse-github-repo-url-1.4.1.tgz#9e7d8bb252a6cb6ba42595060b7bf6df3dbc1f50" - integrity sha1-nn2LslKmy2ukJZUGC3v23z28H1A= - -parse-json@^2.2.0: - version "2.2.0" - resolved "http://registry.npm.dtstack.com/parse-json/-/parse-json-2.2.0.tgz#f480f40434ef80741f8469099f8dea18f55a4dc9" - integrity sha1-9ID0BDTvgHQfhGkJn43qGPVaTck= - dependencies: - error-ex "^1.2.0" - parse-json@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-4.0.0.tgz#be35f5425be1f7f6c747184f98a788cb99477ee0" - integrity sha1-vjX1Qlvh9/bHRxhPmKeIy5lHfuA= + integrity sha512-aOIos8bujGN93/8Ox/jPLh7RwVnPEysynVFE+fQZyg6jKELEHwzgKdLRFHUgXJL6kylijVSBC4BvN9OmsB48Rw== dependencies: error-ex "^1.3.1" json-parse-better-errors "^1.0.1" parse-json@^5.0.0: - version "5.1.0" - resolved "http://registry.npm.dtstack.com/parse-json/-/parse-json-5.1.0.tgz#f96088cdf24a8faa9aea9a009f2d9d942c999646" - integrity sha1-+WCIzfJKj6qa6poAny2dlCyZlkY= + version "5.2.0" + resolved "https://registry.yarnpkg.com/parse-json/-/parse-json-5.2.0.tgz#c76fc66dee54231c962b22bcc8a72cf2f99753cd" + integrity sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg== dependencies: "@babel/code-frame" "^7.0.0" error-ex "^1.3.1" @@ -3606,53 +3714,37 @@ parse5@4.0.0: pascalcase@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/pascalcase/-/pascalcase-0.1.1.tgz#b363e55e8006ca6fe21784d2db22bd15d7917f14" - integrity sha1-s2PlXoAGym/iF4TS2yK9FdeRfxQ= - -path-exists@^2.0.0: - version "2.1.0" - resolved "http://registry.npm.dtstack.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b" - integrity sha1-D+tsZPD8UY2adU3V77YscCJ2H0s= - dependencies: - pinkie-promise "^2.0.0" + integrity sha512-XHXfu/yOQRy9vYOtUDVMN60OEJjW013GoObG1o+xwQTpB9eYJX/BjXMsdW13ZDPruFhYYn0AG22w0xgQMwl3Nw== path-exists@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-3.0.0.tgz#ce0ebeaa5f78cb18925ea7d810d7b59b010fd515" - integrity sha1-zg6+ql94yxiSXqfYENe1mwEP1RU= + integrity sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ== path-exists@^4.0.0: version "4.0.0" - resolved "http://registry.npm.dtstack.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3" + resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-4.0.0.tgz#513bdbe2d3b95d7762e8c1137efa195c6c61b5b3" integrity sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w== path-is-absolute@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" - integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18= + integrity sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg== path-key@^2.0.0, path-key@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/path-key/-/path-key-2.0.1.tgz#411cadb574c5a140d3a4b1910d40d80cc9f40b40" - integrity sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A= + integrity sha512-fEHGKCSmUSDPv4uoj8AlD+joPlq3peND+HRYyxFz4KPw4z926S/b8rIuFs2FYJg3BwsxJf6A9/3eIdLaYC+9Dw== path-key@^3.1.0: version "3.1.1" resolved "https://registry.yarnpkg.com/path-key/-/path-key-3.1.1.tgz#581f6ade658cbba65a0d3380de7753295054f375" integrity sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q== -path-parse@^1.0.6: - version "1.0.6" - resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c" - integrity sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw== - -path-type@^1.0.0: - version "1.1.0" - resolved "http://registry.npm.dtstack.com/path-type/-/path-type-1.1.0.tgz#59c44f7ee491da704da415da5a4070ba4f8fe441" - integrity sha1-WcRPfuSR2nBNpBXaWkBwuk+P5EE= - dependencies: - graceful-fs "^4.1.2" - pify "^2.0.0" - pinkie-promise "^2.0.0" +path-parse@^1.0.7: + version "1.0.7" + resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735" + integrity sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw== path-type@^3.0.0: version "3.0.0" @@ -3664,41 +3756,32 @@ path-type@^3.0.0: performance-now@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/performance-now/-/performance-now-2.1.0.tgz#6309f4e0e5fa913ec1c69307ae364b4b377c9e7b" - integrity sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns= + integrity sha512-7EAHlyLHI56VEIdK57uwHdHKIaAGbnXPiw0yWbarQZOKaKpvUIgW0jWRVLiatnM+XXlSwsanIBH/hzGMJulMow== -pify@^2.0.0, pify@^2.3.0: +picocolors@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/picocolors/-/picocolors-1.0.0.tgz#cb5bdc74ff3f51892236eaf79d68bc44564ab81c" + integrity sha512-1fygroTLlHu66zi26VoTDv8yRgm0Fccecssto+MhsZ0D/DGW2sm8E8AjW7NU5VVTRt5GxbeZ5qBuJr+HyLYkjQ== + +pify@^2.3.0: version "2.3.0" - resolved "http://registry.npm.dtstack.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c" - integrity sha1-7RQaasBDqEnqWISY59yosVMw6Qw= + resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c" + integrity sha512-udgsAY+fTnvv7kI7aaxbqwWNb0AHiB0qBO89PZKPkoTmGOgdbrHDKD+0B2X4uTfJ/FT1R09r9gTsjUjNJotuog== pify@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/pify/-/pify-3.0.0.tgz#e5a4acd2c101fdf3d9a4d07f0dbc4db49dd28176" - integrity sha1-5aSs0sEB/fPZpNB/DbxNtJ3SgXY= + integrity sha512-C3FsVNH1udSEX48gGX1xfvwTWfsYWj5U+8/uK15BGzIGrKoUpghX8hWZwa/OFnakBiiVNmBvemTJR5mcy7iPcg== pify@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231" integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g== -pinkie-promise@^2.0.0: - version "2.0.1" - resolved "http://registry.npm.dtstack.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa" - integrity sha1-ITXW36ejWMBprJsXh3YogihFD/o= - dependencies: - pinkie "^2.0.0" - -pinkie@^2.0.0: - version "2.0.4" - resolved "http://registry.npm.dtstack.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870" - integrity sha1-clVrgM+g1IqXToDnckjoDtT3+HA= - pirates@^4.0.1: - version "4.0.1" - resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.1.tgz#643a92caf894566f91b2b986d2c66950a8e2fb87" - integrity sha512-WuNqLTbMI3tmfef2TKxlQmAiLHKtFhlsCZnPIpuv2Ow0RDVO8lfy1Opf4NUzlMXLjPl+Men7AuVdX6TA+s+uGA== - dependencies: - node-modules-regexp "^1.0.0" + version "4.0.5" + resolved "https://registry.yarnpkg.com/pirates/-/pirates-4.0.5.tgz#feec352ea5c3268fb23a37c702ab1699f35a5f3b" + integrity sha512-8V9+HQPupnaXMA23c5hvl69zXvTwTzyAYasnkb0Tts4XvO4CliqONMOnvlq26rkhLC3nWDFBJf73LU1e1VZLaQ== pkg-dir@^3.0.0: version "3.0.0" @@ -3715,7 +3798,7 @@ pn@^1.1.0: posix-character-classes@^0.1.0: version "0.1.1" resolved "https://registry.yarnpkg.com/posix-character-classes/-/posix-character-classes-0.1.1.tgz#01eac0fe3b5af71a2a6c02feabb8c1fef7e00eab" - integrity sha1-AerA/jta9xoqbAL+q7jB/vfgDqs= + integrity sha512-xTgYBc3fuo7Yt7JbiuFxSYGToMoz8fLoE6TC9Wx1P/u+LfeThMOAqmuyECnlBaaJb+u1m9hHiXUEtwW4OzfUJg== prelude-ls@^1.2.1: version "1.2.1" @@ -3725,7 +3808,7 @@ prelude-ls@^1.2.1: prelude-ls@~1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54" - integrity sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ= + integrity sha512-ESF23V4SKG6lVSGZgYNpbsiaAkdab6ZgOxe52p7+Kid3W3u3bxR4Vfd/o21dmN7jSt0IwgZ4v5MUd26FEtXE9w== pretty-format@^24.9.0: version "24.9.0" @@ -3739,8 +3822,8 @@ pretty-format@^24.9.0: process-nextick-args@~2.0.0: version "2.0.1" - resolved "http://registry.npm.dtstack.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2" - integrity sha1-eCDZsWEgzFXKmud5JoCufbptf+I= + resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-2.0.1.tgz#7820d9b16120cc55ca9ae7792680ae7dba6d7fe2" + integrity sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag== progress@^2.0.0: version "2.0.3" @@ -3748,17 +3831,17 @@ progress@^2.0.0: integrity sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA== prompts@^2.0.1: - version "2.3.2" - resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.3.2.tgz#480572d89ecf39566d2bd3fe2c9fccb7c4c0b068" - integrity sha512-Q06uKs2CkNYVID0VqwfAl9mipo99zkBv/n2JtWY89Yxa3ZabWSrs0e2KTudKVa3peLUvYXMefDqIleLPVUBZMA== + version "2.4.2" + resolved "https://registry.yarnpkg.com/prompts/-/prompts-2.4.2.tgz#7b57e73b3a48029ad10ebd44f74b01722a4cb069" + integrity sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q== dependencies: kleur "^3.0.3" - sisteransi "^1.0.4" + sisteransi "^1.0.5" psl@^1.1.28: - version "1.8.0" - resolved "https://registry.yarnpkg.com/psl/-/psl-1.8.0.tgz#9326f8bcfb013adcc005fdff056acce020e51c24" - integrity sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ== + version "1.9.0" + resolved "https://registry.yarnpkg.com/psl/-/psl-1.9.0.tgz#d0df2a137f00794565fcaf3b2c00cd09f8d5a5a7" + integrity sha512-E/ZsdU4HLs/68gYzgGTkMicWTLPdAftJLfJFlLUAAKZGkStNU72sZjT66SnMDVOfOWY/YAoiD7Jxa9iHvngcag== pump@^3.0.0: version "3.0.0" @@ -3775,41 +3858,28 @@ punycode@^2.1.0, punycode@^2.1.1: q@^1.5.1: version "1.5.1" - resolved "http://registry.npm.dtstack.com/q/-/q-1.5.1.tgz#7e32f75b41381291d04611f1bf14109ac00651d7" - integrity sha1-fjL3W0E4EpHQRhHxvxQQmsAGUdc= + resolved "https://registry.yarnpkg.com/q/-/q-1.5.1.tgz#7e32f75b41381291d04611f1bf14109ac00651d7" + integrity sha512-kV/CThkXo6xyFEZUugw/+pIOywXcDbFYgSct5cT3gqlbkBE1SJdwy6UQoZvodiWF/ckQLZyDE/Bu1M6gVu5lVw== qs@~6.5.2: - version "6.5.2" - resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.2.tgz#cb3ae806e8740444584ef154ce8ee98d403f3e36" - integrity sha512-N5ZAX4/LxJmF+7wN74pUD6qAh9/wnvdQcjq9TZjevvXzSUo7bfmw91saqMjzGS2xq91/odN2dW/WOl7qQHNDGA== - -quick-lru@^1.0.0: - version "1.1.0" - resolved "http://registry.npm.dtstack.com/quick-lru/-/quick-lru-1.1.0.tgz#4360b17c61136ad38078397ff11416e186dcfbb8" - integrity sha1-Q2CxfGETatOAeDl/8RQW4Ybc+7g= + version "6.5.3" + resolved "https://registry.yarnpkg.com/qs/-/qs-6.5.3.tgz#3aeeffc91967ef6e35c0e488ef46fb296ab76aad" + integrity sha512-qxXIEh4pCGfHICj1mAJQ2/2XVZkjCDTcEgfoSQxc/fYivUZxTkk7L3bDBJSoNrEzXI17oUO5Dp07ktqE5KzczA== quick-lru@^4.0.1: version "4.0.1" - resolved "http://registry.npm.dtstack.com/quick-lru/-/quick-lru-4.0.1.tgz#5b8878f113a58217848c6482026c73e1ba57727f" - integrity sha1-W4h48ROlgheEjGSCAmxz4bpXcn8= + resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-4.0.1.tgz#5b8878f113a58217848c6482026c73e1ba57727f" + integrity sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g== react-is@^16.8.4: version "16.13.1" resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4" integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ== -read-pkg-up@^1.0.1: - version "1.0.1" - resolved "http://registry.npm.dtstack.com/read-pkg-up/-/read-pkg-up-1.0.1.tgz#9d63c13276c065918d57f002a57f40a1b643fb02" - integrity sha1-nWPBMnbAZZGNV/ACpX9AobZD+wI= - dependencies: - find-up "^1.0.0" - read-pkg "^1.0.0" - read-pkg-up@^3.0.0: version "3.0.0" - resolved "http://registry.npm.dtstack.com/read-pkg-up/-/read-pkg-up-3.0.0.tgz#3ed496685dba0f8fe118d0691dc51f4a1ff96f07" - integrity sha1-PtSWaF26D4/hGNBpHcUfSh/5bwc= + resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-3.0.0.tgz#3ed496685dba0f8fe118d0691dc51f4a1ff96f07" + integrity sha512-YFzFrVvpC6frF1sz8psoHDBGF7fLPc+llq/8NB43oagqWkx8ar5zYtsTORtOjw9W2RHLpWP+zTWwBvf1bCmcSw== dependencies: find-up "^2.0.0" read-pkg "^3.0.0" @@ -3824,26 +3894,17 @@ read-pkg-up@^4.0.0: read-pkg-up@^7.0.1: version "7.0.1" - resolved "http://registry.npm.dtstack.com/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507" + resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507" integrity sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg== dependencies: find-up "^4.1.0" read-pkg "^5.2.0" type-fest "^0.8.1" -read-pkg@^1.0.0: - version "1.1.0" - resolved "http://registry.npm.dtstack.com/read-pkg/-/read-pkg-1.1.0.tgz#f5ffaa5ecd29cb31c0474bca7d756b6bb29e3f28" - integrity sha1-9f+qXs0pyzHAR0vKfXVra7KePyg= - dependencies: - load-json-file "^1.0.0" - normalize-package-data "^2.3.2" - path-type "^1.0.0" - read-pkg@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-3.0.0.tgz#9cbc686978fee65d16c00e2b19c237fcf6e38389" - integrity sha1-nLxoaXj+5l0WwA4rGcI3/Pbjg4k= + integrity sha512-BLq/cCO9two+lBgiTYNqD6GdtK8s4NpaWrl6/rCO9w0TUS8oJl7cmToOZfRYllKTISY6nt1U7jQ53brmKqY6BA== dependencies: load-json-file "^4.0.0" normalize-package-data "^2.3.2" @@ -3851,7 +3912,7 @@ read-pkg@^3.0.0: read-pkg@^5.2.0: version "5.2.0" - resolved "http://registry.npm.dtstack.com/read-pkg/-/read-pkg-5.2.0.tgz#7bf295438ca5a33e56cd30e053b34ee7250c93cc" + resolved "https://registry.yarnpkg.com/read-pkg/-/read-pkg-5.2.0.tgz#7bf295438ca5a33e56cd30e053b34ee7250c93cc" integrity sha512-Ug69mNOpfvKDAc2Q8DRpMjjzdtrnv9HcSMX+4VsZxD1aZ6ZzrIE7rlzXBtWTyhULSMKg076AW6WR5iZpD0JiOg== dependencies: "@types/normalize-package-data" "^2.4.0" @@ -3861,8 +3922,8 @@ read-pkg@^5.2.0: readable-stream@3, readable-stream@^3.0.0, readable-stream@^3.0.2: version "3.6.0" - resolved "http://registry.npm.dtstack.com/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198" - integrity sha1-M3u9o63AcGvT4CRCaihtS0sskZg= + resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-3.6.0.tgz#337bbda3adc0706bd3e024426a286d4b4b2c9198" + integrity sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA== dependencies: inherits "^2.0.3" string_decoder "^1.1.1" @@ -3870,8 +3931,8 @@ readable-stream@3, readable-stream@^3.0.0, readable-stream@^3.0.2: readable-stream@~2.3.6: version "2.3.7" - resolved "http://registry.npm.dtstack.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57" - integrity sha1-Hsoc9xGu+BTAT2IlKjamL2yyO1c= + resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.3.7.tgz#1eca1cf711aef814c04f62252a36a62f6cb23b57" + integrity sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw== dependencies: core-util-is "~1.0.0" inherits "~2.0.3" @@ -3888,33 +3949,10 @@ realpath-native@^1.1.0: dependencies: util.promisify "^1.0.0" -rechoir@^0.6.2: - version "0.6.2" - resolved "http://registry.npm.dtstack.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384" - integrity sha1-hSBLVNuoLVdC4oyWdW70OvUOM4Q= - dependencies: - resolve "^1.1.6" - -redent@^1.0.0: - version "1.0.0" - resolved "http://registry.npm.dtstack.com/redent/-/redent-1.0.0.tgz#cf916ab1fd5f1f16dfb20822dd6ec7f730c2afde" - integrity sha1-z5Fqsf1fHxbfsggi3W7H9zDCr94= - dependencies: - indent-string "^2.1.0" - strip-indent "^1.0.1" - -redent@^2.0.0: - version "2.0.0" - resolved "http://registry.npm.dtstack.com/redent/-/redent-2.0.0.tgz#c1b2007b42d57eb1389079b3c8333639d5e1ccaa" - integrity sha1-wbIAe0LVfrE4kHmzyDM2OdXhzKo= - dependencies: - indent-string "^3.0.0" - strip-indent "^2.0.0" - redent@^3.0.0: version "3.0.0" - resolved "http://registry.npm.dtstack.com/redent/-/redent-3.0.0.tgz#e557b7998316bb53c9f1f56fa626352c6963059f" - integrity sha1-5Ve3mYMWu1PJ8fVvpiY1LGljBZ8= + resolved "https://registry.yarnpkg.com/redent/-/redent-3.0.0.tgz#e557b7998316bb53c9f1f56fa626352c6963059f" + integrity sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg== dependencies: indent-string "^4.0.0" strip-indent "^3.0.0" @@ -3927,32 +3965,34 @@ regex-not@^1.0.0, regex-not@^1.0.2: extend-shallow "^3.0.2" safe-regex "^1.1.0" +regexp.prototype.flags@^1.4.3: + version "1.4.3" + resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.4.3.tgz#87cab30f80f66660181a3bb7bf5981a872b367ac" + integrity sha512-fjggEOO3slI6Wvgjwflkc4NFRCTZAu5CnNfBd5qOMYhWdn67nJBBu34/TkD++eeFmd8C9r9jfXJ27+nSiRkSUA== + dependencies: + call-bind "^1.0.2" + define-properties "^1.1.3" + functions-have-names "^1.2.2" + regexpp@^3.0.0, regexpp@^3.1.0: - version "3.1.0" - resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.1.0.tgz#206d0ad0a5648cffbdb8ae46438f3dc51c9f78e2" - integrity sha512-ZOIzd8yVsQQA7j8GCSlPGXwg5PfmA1mrq0JP4nGhh54LaKN3xdai/vHUDu74pKwV8OxseMS65u2NImosQcSD0Q== + version "3.2.0" + resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.2.0.tgz#0425a2768d8f23bad70ca4b90461fa2f1213e1b2" + integrity sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg== remove-trailing-separator@^1.0.1: version "1.1.0" resolved "https://registry.yarnpkg.com/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz#c24bce2a283adad5bc3f58e0d48249b92379d8ef" - integrity sha1-wkvOKig62tW8P1jg1IJJuSN52O8= + integrity sha512-/hS+Y0u3aOfIETiaiirUFwDBDzmXPvO+jAfKTitUngIPzdKc6Z0LoFjM/CK5PL4C+eKwHohlHAb6H0VFfmmUsw== repeat-element@^1.1.2: - version "1.1.3" - resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.3.tgz#782e0d825c0c5a3bb39731f84efee6b742e6b1ce" - integrity sha512-ahGq0ZnV5m5XtZLMb+vP76kcAM5nkLqk0lpqAuojSKGgQtn4eRi4ZZGm2olo2zKFH+sMsWaqOCW1dqAnOru72g== + version "1.1.4" + resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.4.tgz#be681520847ab58c7568ac75fbfad28ed42d39e9" + integrity sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ== repeat-string@^1.6.1: version "1.6.1" resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637" - integrity sha1-jcrkcOHIirwtYA//Sndihtp15jc= - -repeating@^2.0.0: - version "2.0.1" - resolved "http://registry.npm.dtstack.com/repeating/-/repeating-2.0.1.tgz#5214c53a926d3552707527fbab415dbc08d06dda" - integrity sha1-UhTFOpJtNVJwdSf7q0FdvAjQbdo= - dependencies: - is-finite "^1.0.0" + integrity sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w== request-promise-core@1.1.4: version "1.1.4" @@ -3999,7 +4039,12 @@ request@^2.87.0: require-directory@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/require-directory/-/require-directory-2.1.1.tgz#8c64ad5fd30dab1c976e2344ffe7f792a6a6df42" - integrity sha1-jGStX9MNqxyXbiNE/+f3kqam30I= + integrity sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q== + +require-from-string@^2.0.2: + version "2.0.2" + resolved "https://registry.yarnpkg.com/require-from-string/-/require-from-string-2.0.2.tgz#89a7fdd938261267318eafe14f9c32e598c36909" + integrity sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw== require-main-filename@^2.0.0: version "2.0.0" @@ -4009,14 +4054,14 @@ require-main-filename@^2.0.0: resolve-cwd@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/resolve-cwd/-/resolve-cwd-2.0.0.tgz#00a9f7387556e27038eae232caa372a6a59b665a" - integrity sha1-AKn3OHVW4nA46uIyyqNypqWbZlo= + integrity sha512-ccu8zQTrzVr954472aUVPLEcB3YpKSYR3cg/3lo1okzobPBM+1INXBbBZlDbnI/hbEocnf8j0QVo43hQKrbchg== dependencies: resolve-from "^3.0.0" resolve-from@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-3.0.0.tgz#b22c7af7d9d6881bc8b6e653335eebcb0a188748" - integrity sha1-six699nWiBvItuZTM17rywoYh0g= + integrity sha512-GnlH6vxLymXJNMBo7XP1fJIzBFbdYt49CuTwmB/6N53t+kMPRMFKz783LlQ4tv28XoQfMWinAJX6WCGf2IlaIw== resolve-from@^4.0.0: version "4.0.0" @@ -4026,40 +4071,27 @@ resolve-from@^4.0.0: resolve-url@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a" - integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo= + integrity sha512-ZuF55hVUQaaczgOIwqWzkEcEidmlD/xl44x1UZnhOXcYuFN2S6+rcxpG+C1N3So0wvNI3DmJICUFfu2SxhBmvg== resolve@1.1.7: version "1.1.7" resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.1.7.tgz#203114d82ad2c5ed9e8e0411b3932875e889e97b" - integrity sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs= + integrity sha512-9znBF0vBcaSN3W2j7wKvdERPwqTxSpCq+if5C0WoTCyV9n24rua28jeuQ2pL/HOf+yUe/Mef+H/5p60K0Id3bg== -resolve@1.x, resolve@^1.10.0, resolve@^1.3.2: - version "1.17.0" - resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.17.0.tgz#b25941b54968231cc2d1bb76a79cb7f2c0bf8444" - integrity sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w== +resolve@1.x, resolve@^1.10.0: + version "1.22.1" + resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.22.1.tgz#27cb2ebb53f91abb49470a928bba7558066ac177" + integrity sha512-nBpuuYuY5jFsli/JIs1oldw6fOQCBioohqWZg/2hiaOybXOft4lonv85uDOKXdf8rhyK159cxU5cDcK/NKk8zw== dependencies: - path-parse "^1.0.6" - -resolve@^1.1.6, resolve@^1.17.0: - version "1.19.0" - resolved "http://registry.npm.dtstack.com/resolve/-/resolve-1.19.0.tgz#1af5bf630409734a067cae29318aac7fa29a267c" - integrity sha1-GvW/YwQJc0oGfK4pMYqsf6KaJnw= - dependencies: - is-core-module "^2.1.0" - path-parse "^1.0.6" + is-core-module "^2.9.0" + path-parse "^1.0.7" + supports-preserve-symlinks-flag "^1.0.0" ret@~0.1.10: version "0.1.15" resolved "https://registry.yarnpkg.com/ret/-/ret-0.1.15.tgz#b8a4825d5bdb1fc3f6f53c2bc33f81388681c7bc" integrity sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg== -rimraf@2.6.3: - version "2.6.3" - resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.3.tgz#b2d104fe0d8fb27cf9e0a1cda8262dd3833c6cab" - integrity sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA== - dependencies: - glob "^7.1.3" - rimraf@^2.5.4, rimraf@^2.6.3: version "2.7.1" resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.7.1.tgz#35797f13a7fdadc566142c29d4f07ccad483e3ec" @@ -4067,6 +4099,13 @@ rimraf@^2.5.4, rimraf@^2.6.3: dependencies: glob "^7.1.3" +rimraf@^3.0.2: + version "3.0.2" + resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-3.0.2.tgz#f1a5402ba6220ad52cc1282bac1ae3aa49fd061a" + integrity sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA== + dependencies: + glob "^7.1.3" + rsvp@^4.8.4: version "4.8.5" resolved "https://registry.yarnpkg.com/rsvp/-/rsvp-4.8.5.tgz#c8f155311d167f68f21e168df71ec5b083113734" @@ -4082,10 +4121,19 @@ safe-buffer@~5.1.0, safe-buffer@~5.1.1: resolved "https://registry.yarnpkg.com/safe-buffer/-/safe-buffer-5.1.2.tgz#991ec69d296e0313747d59bdfd2b745c35f8828d" integrity sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g== +safe-regex-test@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/safe-regex-test/-/safe-regex-test-1.0.0.tgz#793b874d524eb3640d1873aad03596db2d4f2295" + integrity sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA== + dependencies: + call-bind "^1.0.2" + get-intrinsic "^1.1.3" + is-regex "^1.1.4" + safe-regex@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/safe-regex/-/safe-regex-1.1.0.tgz#40a3669f3b077d1e943d44629e157dd48023bf2e" - integrity sha1-QKNmnzsHfR6UPURinhV91IAjvy4= + integrity sha512-aJXcif4xnaNUzvUuC5gcb46oTS7zvg4jpMTnuqtrEPlR3vFr4pxtdTwaF1Qs3Enjn9HK+ZlwQui+a7z0SywIzg== dependencies: ret "~0.1.10" @@ -4114,32 +4162,27 @@ sax@^1.2.4: resolved "https://registry.yarnpkg.com/sax/-/sax-1.2.4.tgz#2816234e2378bddc4e5354fab5caa895df7100d9" integrity sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw== -"semver@2 || 3 || 4 || 5", semver@^5.4.1, semver@^5.5, semver@^5.5.0, semver@^5.6.0: +"semver@2 || 3 || 4 || 5", semver@^5.5, semver@^5.5.0, semver@^5.6.0: version "5.7.1" resolved "https://registry.yarnpkg.com/semver/-/semver-5.7.1.tgz#a954f931aeba508d307bbf069eff0c01c96116f7" integrity sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ== -semver@^6.0.0, semver@^6.2.0: +semver@^6.0.0, semver@^6.2.0, semver@^6.3.0: version "6.3.0" resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d" integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw== -semver@^7.1.1: - version "7.3.4" - resolved "http://registry.npm.dtstack.com/semver/-/semver-7.3.4.tgz#27aaa7d2e4ca76452f98d3add093a72c943edc97" - integrity sha1-J6qn0uTKdkUvmNOt0JOnLJQ+3Jc= +semver@^7.1.1, semver@^7.2.1, semver@^7.3.2, semver@^7.3.4: + version "7.3.8" + resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.8.tgz#07a78feafb3f7b32347d725e33de7e2a2df67798" + integrity sha512-NB1ctGL5rlHrPJtFDVIVzTyQylMLu9N9VICA6HSFJo8MCGVTMW6gfpicwKmmK/dAjTOrqu5l63JJOpDSrAis3A== dependencies: lru-cache "^6.0.0" -semver@^7.2.1, semver@^7.3.2: - version "7.3.2" - resolved "https://registry.yarnpkg.com/semver/-/semver-7.3.2.tgz#604962b052b81ed0786aae84389ffba70ffd3938" - integrity sha512-OrOb32TeeambH6UrhtShmF7CRDqhL6/5XpPNp2DuRH6+9QLw/orhp72j87v8Qa1ScDkvrrBNpZcDejAirJmfXQ== - set-blocking@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/set-blocking/-/set-blocking-2.0.0.tgz#045f9782d011ae9a6803ddd382b24392b3d890f7" - integrity sha1-BF+XgtARrppoA93TgrJDkrPYkPc= + integrity sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw== set-value@^2.0.0, set-value@^2.0.1: version "2.0.1" @@ -4154,7 +4197,7 @@ set-value@^2.0.0, set-value@^2.0.1: shebang-command@^1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/shebang-command/-/shebang-command-1.2.0.tgz#44aac65b695b03398968c39f363fee5deafdf1ea" - integrity sha1-RKrGW2lbAzmJaMOfNj/uXer98eo= + integrity sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg== dependencies: shebang-regex "^1.0.0" @@ -4168,33 +4211,33 @@ shebang-command@^2.0.0: shebang-regex@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-1.0.0.tgz#da42f49740c0b42db2ca9728571cb190c98efea3" - integrity sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM= + integrity sha512-wpoSFAxys6b2a2wHZ1XpDSgD7N9iVjg29Ph9uV/uaP9Ex/KXlkTZTeddxDPSYQpgvzKLGJke2UU0AzoGCjNIvQ== shebang-regex@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/shebang-regex/-/shebang-regex-3.0.0.tgz#ae16f1644d873ecad843b0307b143362d4c42172" integrity sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A== -shelljs@^0.8.3: - version "0.8.4" - resolved "http://registry.npm.dtstack.com/shelljs/-/shelljs-0.8.4.tgz#de7684feeb767f8716b326078a8a00875890e3c2" - integrity sha1-3naE/ut2f4cWsyYHiooAh1iQ48I= - dependencies: - glob "^7.0.0" - interpret "^1.0.0" - rechoir "^0.6.2" - shellwords@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/shellwords/-/shellwords-0.1.1.tgz#d6b9181c1a48d397324c84871efbcfc73fc0654b" integrity sha512-vFwSUfQvqybiICwZY5+DAWIPLKsWO31Q91JSKl3UYv+K5c2QRPzn0qzec6QPu1Qc9eHYItiP3NdJqNVqetYAww== -signal-exit@^3.0.0, signal-exit@^3.0.2: - version "3.0.3" - resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.3.tgz#a1410c2edd8f077b08b4e253c8eacfcaf057461c" - integrity sha512-VUJ49FC8U1OxwZLxIbTTrDvLnf/6TDgxZcK8wxR8zs13xpx7xbG60ndBlhNrFi2EMuFRoeDoJO7wthSLq42EjA== +side-channel@^1.0.4: + version "1.0.4" + resolved "https://registry.yarnpkg.com/side-channel/-/side-channel-1.0.4.tgz#efce5c8fdc104ee751b25c58d4290011fa5ea2cf" + integrity sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw== + dependencies: + call-bind "^1.0.0" + get-intrinsic "^1.0.2" + object-inspect "^1.9.0" -sisteransi@^1.0.4: +signal-exit@^3.0.0, signal-exit@^3.0.2: + version "3.0.7" + resolved "https://registry.yarnpkg.com/signal-exit/-/signal-exit-3.0.7.tgz#a9a1767f8af84155114eaabd73f99273c8f59ad9" + integrity sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ== + +sisteransi@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/sisteransi/-/sisteransi-1.0.5.tgz#134d681297756437cc05ca01370d3a7a571075ed" integrity sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg== @@ -4204,14 +4247,14 @@ slash@^2.0.0: resolved "https://registry.yarnpkg.com/slash/-/slash-2.0.0.tgz#de552851a1759df3a8f206535442f5ec4ddeab44" integrity sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A== -slice-ansi@^2.1.0: - version "2.1.0" - resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-2.1.0.tgz#cacd7693461a637a5788d92a7dd4fba068e81636" - integrity sha512-Qu+VC3EwYLldKa1fCxuuvULvSJOKEgk9pi8dZeCVK7TqBfUNTH4sFkk4joj8afVSfAYgJoSOetjx9QWOJ5mYoQ== +slice-ansi@^4.0.0: + version "4.0.0" + resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b" + integrity sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ== dependencies: - ansi-styles "^3.2.0" - astral-regex "^1.0.0" - is-fullwidth-code-point "^2.0.0" + ansi-styles "^4.0.0" + astral-regex "^2.0.0" + is-fullwidth-code-point "^3.0.0" snapdragon-node@^2.0.1: version "2.1.1" @@ -4255,22 +4298,22 @@ source-map-resolve@^0.5.0: urix "^0.1.0" source-map-support@^0.5.6: - version "0.5.19" - resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.19.tgz#a98b62f86dcaf4f67399648c085291ab9e8fed61" - integrity sha512-Wonm7zOCIJzBGQdB+thsPar0kYuCIzYvxZwlBa87yi/Mdjv7Tip2cyVbLj5o0cFPN4EVkuTwb3GDDyUx2DGnGw== + version "0.5.21" + resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f" + integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w== dependencies: buffer-from "^1.0.0" source-map "^0.6.0" source-map-url@^0.4.0: - version "0.4.0" - resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.0.tgz#3e935d7ddd73631b97659956d55128e87b5084a3" - integrity sha1-PpNdfd1zYxuXZZlW1VEo6HtQhKM= + version "0.4.1" + resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.4.1.tgz#0af66605a745a5a2f91cf1bbf8a7afbc283dec56" + integrity sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw== -source-map@^0.5.0, source-map@^0.5.6: +source-map@^0.5.6: version "0.5.7" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.7.tgz#8a039d2d1021d22d1ea14c80d8ea468ba2ef3fcc" - integrity sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w= + integrity sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ== source-map@^0.6.0, source-map@^0.6.1, source-map@~0.6.1: version "0.6.1" @@ -4299,9 +4342,9 @@ spdx-expression-parse@^3.0.0: spdx-license-ids "^3.0.0" spdx-license-ids@^3.0.0: - version "3.0.5" - resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.5.tgz#3694b5804567a458d3c8045842a6358632f62654" - integrity sha512-J+FWzZoynJEXGphVIS+XEh3kFSjZX/1i9gFBaWQcB+/tmpe2qUsSBABpcxqxnAxFdiUFEgAX1bjYGQvIZmoz9Q== + version "3.0.12" + resolved "https://registry.yarnpkg.com/spdx-license-ids/-/spdx-license-ids-3.0.12.tgz#69077835abe2710b65f03969898b6637b505a779" + integrity sha512-rr+VVSXtRhO4OHbXUiAF7xW3Bo9DuuF6C5jH+q/x15j2jniycgKbxU09Hr0WqlSLUs4i4ltHGXqTe7VHclYWyA== split-string@^3.0.1, split-string@^3.0.2: version "3.1.0" @@ -4310,36 +4353,29 @@ split-string@^3.0.1, split-string@^3.0.2: dependencies: extend-shallow "^3.0.0" -split2@^2.0.0: - version "2.2.0" - resolved "http://registry.npm.dtstack.com/split2/-/split2-2.2.0.tgz#186b2575bcf83e85b7d18465756238ee4ee42493" - integrity sha1-GGsldbz4PoW30YRldWI47k7kJJM= - dependencies: - through2 "^2.0.2" - split2@^3.0.0: version "3.2.2" - resolved "http://registry.npm.dtstack.com/split2/-/split2-3.2.2.tgz#bf2cf2a37d838312c249c89206fd7a17dd12365f" - integrity sha1-vyzyo32DgxLCSciSBv16F90SNl8= + resolved "https://registry.yarnpkg.com/split2/-/split2-3.2.2.tgz#bf2cf2a37d838312c249c89206fd7a17dd12365f" + integrity sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg== dependencies: readable-stream "^3.0.0" split@^1.0.0: version "1.0.1" - resolved "http://registry.npm.dtstack.com/split/-/split-1.0.1.tgz#605bd9be303aa59fb35f9229fbea0ddec9ea07d9" - integrity sha1-YFvZvjA6pZ+zX5Ip++oN3snqB9k= + resolved "https://registry.yarnpkg.com/split/-/split-1.0.1.tgz#605bd9be303aa59fb35f9229fbea0ddec9ea07d9" + integrity sha512-mTyOoPbrivtXnwnIxZRFYRrPNtEFKlpB2fvjSnCQUiAA6qAZzqwna5envK4uk6OIeP17CsdF3rSBGYVBsU0Tkg== dependencies: through "2" sprintf-js@~1.0.2: version "1.0.3" resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c" - integrity sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw= + integrity sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g== sshpk@^1.7.0: - version "1.16.1" - resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.16.1.tgz#fb661c0bef29b39db40769ee39fa70093d6f6877" - integrity sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg== + version "1.17.0" + resolved "https://registry.yarnpkg.com/sshpk/-/sshpk-1.17.0.tgz#578082d92d4fe612b13007496e543fa0fbcbe4c5" + integrity sha512-/9HIEs1ZXGhSPE8X6Ccm7Nam1z8KcoCqPdI7ecm1N33EzAetWahvQWVqLZtaZQ+IDKX4IyA2o0gBzqIMkAagHQ== dependencies: asn1 "~0.2.3" assert-plus "^1.0.0" @@ -4352,35 +4388,36 @@ sshpk@^1.7.0: tweetnacl "~0.14.0" stack-utils@^1.0.1: - version "1.0.2" - resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-1.0.2.tgz#33eba3897788558bebfc2db059dc158ec36cebb8" - integrity sha512-MTX+MeG5U994cazkjd/9KNAapsHnibjMLnfXodlkXw76JEea0UiNzrqidzo1emMwk7w5Qhc9jd4Bn9TBb1MFwA== + version "1.0.5" + resolved "https://registry.yarnpkg.com/stack-utils/-/stack-utils-1.0.5.tgz#a19b0b01947e0029c8e451d5d61a498f5bb1471b" + integrity sha512-KZiTzuV3CnSnSvgMRrARVCj+Ht7rMbauGDK0LdVFRGyenwdylpajAp4Q0i6SX8rEmbTpMMf6ryq2gb8pPq2WgQ== + dependencies: + escape-string-regexp "^2.0.0" standard-version@^9.1.0: - version "9.1.0" - resolved "http://registry.npm.dtstack.com/standard-version/-/standard-version-9.1.0.tgz#07589469324d967ffe665fa86ef612949a858a80" - integrity sha512-EJcbKUGKBuHjiDSUL5XjPhT1KGVM+UCvv/ti70fHnJwJyJqTSJWl0mWj/Wj0WwsoskyvKWURESzBsZmCCMUZzg== + version "9.5.0" + resolved "https://registry.yarnpkg.com/standard-version/-/standard-version-9.5.0.tgz#851d6dcddf5320d5079601832aeb185dbf497949" + integrity sha512-3zWJ/mmZQsOaO+fOlsa0+QK90pwhNd042qEcw6hKFNoLFs7peGyvPffpEBbK/DSGPbyOvli0mUIFv5A4qTjh2Q== dependencies: chalk "^2.4.2" - conventional-changelog "3.1.24" + conventional-changelog "3.1.25" conventional-changelog-config-spec "2.1.0" - conventional-changelog-conventionalcommits "4.5.0" - conventional-recommended-bump "6.0.11" + conventional-changelog-conventionalcommits "4.6.3" + conventional-recommended-bump "6.1.0" detect-indent "^6.0.0" detect-newline "^3.1.0" dotgitignore "^2.1.0" figures "^3.1.0" find-up "^5.0.0" - fs-access "^1.0.1" git-semver-tags "^4.0.0" semver "^7.1.1" stringify-package "^1.0.1" - yargs "^15.3.1" + yargs "^16.0.0" static-extend@^0.1.1: version "0.1.2" resolved "https://registry.yarnpkg.com/static-extend/-/static-extend-0.1.2.tgz#60809c39cbff55337226fd5e0b520f341f1fb5c6" - integrity sha1-YICcOcv/VTNyJv1eC1IPNB8ftcY= + integrity sha512-72E9+uLc27Mt718pMHt9VMNiAL4LMsmDbBva8mxWUCkT07fSzEGMYUCk0XWY6lp0j6RBAG4cJ3mWuZv2OE3s0g== dependencies: define-property "^0.2.5" object-copy "^0.1.0" @@ -4388,12 +4425,12 @@ static-extend@^0.1.1: stealthy-require@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/stealthy-require/-/stealthy-require-1.1.1.tgz#35b09875b4ff49f26a777e509b3090a3226bf24b" - integrity sha1-NbCYdbT/SfJqd35QmzCQoyJr8ks= + integrity sha512-ZnWpYnYugiOVEY5GkcuJK1io5V8QmNYChG62gSit9pQVGErXtrKuPC55ITaVSukmMta5qpMU7vqLt2Lnni4f/g== string-length@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/string-length/-/string-length-2.0.0.tgz#d40dbb686a3ace960c1cffca562bf2c45f8363ed" - integrity sha1-1A27aGo6zpYMHP/KVivyxF+DY+0= + integrity sha512-Qka42GGrS8Mm3SZ+7cH8UXiIWI867/b/Z/feQSpQx/rbfB8UGknGEZVaUQMOUVj+soY6NpWAxily63HI1OckVQ== dependencies: astral-regex "^1.0.0" strip-ansi "^4.0.0" @@ -4407,54 +4444,56 @@ string-width@^3.0.0, string-width@^3.1.0: is-fullwidth-code-point "^2.0.0" strip-ansi "^5.1.0" -string-width@^4.1.0, string-width@^4.2.0: - version "4.2.0" - resolved "http://registry.npm.dtstack.com/string-width/-/string-width-4.2.0.tgz#952182c46cc7b2c313d1596e623992bd163b72b5" - integrity sha512-zUz5JD+tgqtuDjMhwIg5uFVV3dtqZ9yQJlZVfq4I01/K5Paj5UHj7VyrQOJvzawSVlKpObApbfD0Ed6yJc+1eg== +string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.3: + version "4.2.3" + resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010" + integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g== dependencies: emoji-regex "^8.0.0" is-fullwidth-code-point "^3.0.0" - strip-ansi "^6.0.0" + strip-ansi "^6.0.1" -string.prototype.trimend@^1.0.1: - version "1.0.1" - resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.1.tgz#85812a6b847ac002270f5808146064c995fb6913" - integrity sha512-LRPxFUaTtpqYsTeNKaFOw3R4bxIzWOnbQ837QfBylo8jIxtcbK/A/sMV7Q+OAV/vWo+7s25pOE10KYSjaSO06g== +string.prototype.trimend@^1.0.6: + version "1.0.6" + resolved "https://registry.yarnpkg.com/string.prototype.trimend/-/string.prototype.trimend-1.0.6.tgz#c4a27fa026d979d79c04f17397f250a462944533" + integrity sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ== dependencies: - define-properties "^1.1.3" - es-abstract "^1.17.5" + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" -string.prototype.trimstart@^1.0.1: - version "1.0.1" - resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.1.tgz#14af6d9f34b053f7cfc89b72f8f2ee14b9039a54" - integrity sha512-XxZn+QpvrBI1FOcg6dIpxUPgWCPuNXvMD72aaRaUQv1eD4e/Qy8i/hFTe0BUmD60p/QA6bh1avmuPTfNjqVWRw== +string.prototype.trimstart@^1.0.6: + version "1.0.6" + resolved "https://registry.yarnpkg.com/string.prototype.trimstart/-/string.prototype.trimstart-1.0.6.tgz#e90ab66aa8e4007d92ef591bbf3cd422c56bdcf4" + integrity sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA== dependencies: - define-properties "^1.1.3" - es-abstract "^1.17.5" + call-bind "^1.0.2" + define-properties "^1.1.4" + es-abstract "^1.20.4" string_decoder@^1.1.1: version "1.3.0" - resolved "http://registry.npm.dtstack.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e" - integrity sha1-QvEUWUpGzxqOMLCoT1bHjD7awh4= + resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.3.0.tgz#42f114594a46cf1a8e30b0a84f56c78c3edac21e" + integrity sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA== dependencies: safe-buffer "~5.2.0" string_decoder@~1.1.1: version "1.1.1" - resolved "http://registry.npm.dtstack.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8" - integrity sha1-nPFhG6YmhdcDCunkujQUnDrwP8g= + resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-1.1.1.tgz#9cf1611ba62685d7030ae9e4ba34149c3af03fc8" + integrity sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg== dependencies: safe-buffer "~5.1.0" stringify-package@^1.0.1: version "1.0.1" - resolved "http://registry.npm.dtstack.com/stringify-package/-/stringify-package-1.0.1.tgz#e5aa3643e7f74d0f28628b72f3dad5cecfc3ba85" + resolved "https://registry.yarnpkg.com/stringify-package/-/stringify-package-1.0.1.tgz#e5aa3643e7f74d0f28628b72f3dad5cecfc3ba85" integrity sha512-sa4DUQsYciMP1xhKWGuFM04fB0LG/9DlluZoSVywUMRNvzid6XucHK0/90xGxRoHrAaROrcHK1aPKaijCtSrhg== strip-ansi@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-4.0.0.tgz#a8479022eb1ac368a871389b635262c505ee368f" - integrity sha1-qEeQIusaw2iocTibY1JixQXuNo8= + integrity sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow== dependencies: ansi-regex "^3.0.0" @@ -4465,50 +4504,31 @@ strip-ansi@^5.0.0, strip-ansi@^5.1.0, strip-ansi@^5.2.0: dependencies: ansi-regex "^4.1.0" -strip-ansi@^6.0.0: - version "6.0.0" - resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.0.tgz#0b1571dd7669ccd4f3e06e14ef1eed26225ae532" - integrity sha512-AuvKTrTfQNYNIctbR1K/YGTR1756GycPsg7b9bdV9Duqur4gv6aKqHXah67Z8ImS7WEz5QVcOtlfW2rZEugt6w== +strip-ansi@^6.0.0, strip-ansi@^6.0.1: + version "6.0.1" + resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9" + integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A== dependencies: - ansi-regex "^5.0.0" - -strip-bom@^2.0.0: - version "2.0.0" - resolved "http://registry.npm.dtstack.com/strip-bom/-/strip-bom-2.0.0.tgz#6219a85616520491f35788bdbf1447a99c7e6b0e" - integrity sha1-YhmoVhZSBJHzV4i9vxRHqZx+aw4= - dependencies: - is-utf8 "^0.2.0" + ansi-regex "^5.0.1" strip-bom@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3" - integrity sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM= + integrity sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA== strip-eof@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/strip-eof/-/strip-eof-1.0.0.tgz#bb43ff5598a6eb05d89b59fcd129c983313606bf" - integrity sha1-u0P/VZim6wXYm1n80SnJgzE2Br8= - -strip-indent@^1.0.1: - version "1.0.1" - resolved "http://registry.npm.dtstack.com/strip-indent/-/strip-indent-1.0.1.tgz#0c7962a6adefa7bbd4ac366460a638552ae1a0a2" - integrity sha1-DHlipq3vp7vUrDZkYKY4VSrhoKI= - dependencies: - get-stdin "^4.0.1" - -strip-indent@^2.0.0: - version "2.0.0" - resolved "http://registry.npm.dtstack.com/strip-indent/-/strip-indent-2.0.0.tgz#5ef8db295d01e6ed6cbf7aab96998d7822527b68" - integrity sha1-XvjbKV0B5u1sv3qrlpmNeCJSe2g= + integrity sha512-7FCwGGmx8mD5xQd3RPUvnSpUXHM3BWuzjtpD4TXsfcZ9EL4azvVVUscFYwD9nx8Kh+uCBC00XBtAykoMHwTh8Q== strip-indent@^3.0.0: version "3.0.0" - resolved "http://registry.npm.dtstack.com/strip-indent/-/strip-indent-3.0.0.tgz#c32e1cee940b6b3432c771bc2c54bcce73cd3001" - integrity sha1-wy4c7pQLazQyx3G8LFS8znPNMAE= + resolved "https://registry.yarnpkg.com/strip-indent/-/strip-indent-3.0.0.tgz#c32e1cee940b6b3432c771bc2c54bcce73cd3001" + integrity sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ== dependencies: min-indent "^1.0.0" -strip-json-comments@^3.1.0: +strip-json-comments@^3.1.0, strip-json-comments@^3.1.1: version "3.1.1" resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-3.1.1.tgz#31f1281b3832630434831c310c01cccda8cbe006" integrity sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig== @@ -4528,26 +4548,32 @@ supports-color@^6.1.0: has-flag "^3.0.0" supports-color@^7.1.0: - version "7.1.0" - resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.1.0.tgz#68e32591df73e25ad1c4b49108a2ec507962bfd1" - integrity sha512-oRSIpR8pxT1Wr2FquTNnGet79b3BWljqOuoW/h4oBhxJ/HUbX5nX6JSruTkvXDCFMwDPvsaTTbvMLKZWSy0R5g== + version "7.2.0" + resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-7.2.0.tgz#1b7dcdcb32b8138801b3e478ba6a51caa89648da" + integrity sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw== dependencies: has-flag "^4.0.0" +supports-preserve-symlinks-flag@^1.0.0: + version "1.0.0" + resolved "https://registry.yarnpkg.com/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz#6eda4bd344a3c94aea376d4cc31bc77311039e09" + integrity sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w== + symbol-tree@^3.2.2: version "3.2.4" resolved "https://registry.yarnpkg.com/symbol-tree/-/symbol-tree-3.2.4.tgz#430637d248ba77e078883951fb9aa0eed7c63fa2" integrity sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw== -table@^5.2.3: - version "5.4.6" - resolved "https://registry.yarnpkg.com/table/-/table-5.4.6.tgz#1292d19500ce3f86053b05f0e8e7e4a3bb21079e" - integrity sha512-wmEc8m4fjnob4gt5riFRtTu/6+4rSe12TpAELNSqHMfF3IqnA+CH37USM6/YR3qRZv7e56kAEAtd6nKZaxe0Ug== +table@^6.0.9: + version "6.8.1" + resolved "https://registry.yarnpkg.com/table/-/table-6.8.1.tgz#ea2b71359fe03b017a5fbc296204471158080bdf" + integrity sha512-Y4X9zqrCftUhMeH2EptSSERdVKt/nEdijTOacGD/97EKjhQ/Qs8RTlEGABSJNNN8lac9kheH+af7yAkEWlgneA== dependencies: - ajv "^6.10.2" - lodash "^4.17.14" - slice-ansi "^2.1.0" - string-width "^3.0.0" + ajv "^8.0.1" + lodash.truncate "^4.4.2" + slice-ansi "^4.0.0" + string-width "^4.2.3" + strip-ansi "^6.0.1" test-exclude@^5.2.3: version "5.2.3" @@ -4561,60 +4587,60 @@ test-exclude@^5.2.3: text-extensions@^1.0.0: version "1.9.0" - resolved "http://registry.npm.dtstack.com/text-extensions/-/text-extensions-1.9.0.tgz#1853e45fee39c945ce6f6c36b2d659b5aabc2a26" - integrity sha1-GFPkX+45yUXOb2w2stZZtaq8KiY= + resolved "https://registry.yarnpkg.com/text-extensions/-/text-extensions-1.9.0.tgz#1853e45fee39c945ce6f6c36b2d659b5aabc2a26" + integrity sha512-wiBrwC1EhBelW12Zy26JeOUkQ5mRu+5o8rpsJk5+2t+Y5vE7e842qtZDQ2g1NpX/29HdyFeJ4nSIhI47ENSxlQ== text-table@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4" - integrity sha1-f17oI66AUgfACvLfSoTsP8+lcLQ= + integrity sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw== throat@^4.0.0: version "4.1.0" resolved "https://registry.yarnpkg.com/throat/-/throat-4.1.0.tgz#89037cbc92c56ab18926e6ba4cbb200e15672a6a" - integrity sha1-iQN8vJLFarGJJua6TLsgDhVnKmo= + integrity sha512-wCVxLDcFxw7ujDxaeJC6nfl2XfHJNYs8yUYJnvMgtPEFlttP9tHSfRUv2vBe6C4hkVFPWoP1P6ZccbYjmSEkKA== -through2@^2.0.0, through2@^2.0.2: +through2@^2.0.0: version "2.0.5" - resolved "http://registry.npm.dtstack.com/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd" - integrity sha1-AcHjnrMdB8t9A6lqcIIyYLIxMs0= + resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.5.tgz#01c1e39eb31d07cb7d03a96a70823260b23132cd" + integrity sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ== dependencies: readable-stream "~2.3.6" xtend "~4.0.1" through2@^4.0.0: version "4.0.2" - resolved "http://registry.npm.dtstack.com/through2/-/through2-4.0.2.tgz#a7ce3ac2a7a8b0b966c80e7c49f0484c3b239764" - integrity sha1-p846wqeosLlmyA58SfBITDsjl2Q= + resolved "https://registry.yarnpkg.com/through2/-/through2-4.0.2.tgz#a7ce3ac2a7a8b0b966c80e7c49f0484c3b239764" + integrity sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw== dependencies: readable-stream "3" through@2, "through@>=2.2.7 <3": version "2.3.8" - resolved "http://registry.npm.dtstack.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5" - integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU= + resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5" + integrity sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg== -tmpl@1.0.x: - version "1.0.4" - resolved "https://registry.yarnpkg.com/tmpl/-/tmpl-1.0.4.tgz#23640dd7b42d00433911140820e5cf440e521dd1" - integrity sha1-I2QN17QtAEM5ERQIIOXPRA5SHdE= +tmpl@1.0.5: + version "1.0.5" + resolved "https://registry.yarnpkg.com/tmpl/-/tmpl-1.0.5.tgz#8683e0b902bb9c20c4f726e3c0b69f36518c07cc" + integrity sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw== to-fast-properties@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-2.0.0.tgz#dc5e698cbd079265bc73e0377681a4e4e83f616e" - integrity sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4= + integrity sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog== to-object-path@^0.3.0: version "0.3.0" resolved "https://registry.yarnpkg.com/to-object-path/-/to-object-path-0.3.0.tgz#297588b7b0e7e0ac08e04e672f85c1f4999e17af" - integrity sha1-KXWIt7Dn4KwI4E5nL4XB9JmeF68= + integrity sha512-9mWHdnGRuh3onocaHzukyvCZhzvr6tiflAy/JRFXcJX0TjgfWA9pk9t8CMbzmBE4Jfw58pXbkngtBtqYxzNEyg== dependencies: kind-of "^3.0.2" to-regex-range@^2.1.0: version "2.1.1" resolved "https://registry.yarnpkg.com/to-regex-range/-/to-regex-range-2.1.1.tgz#7c80c17b9dfebe599e27367e0d4dd5590141db38" - integrity sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg= + integrity sha512-ZZWNfCjUokXXDGXFpZehJIkZqq91BcULFq/Pi7M5i4JnxXdhMKAK682z8bCW3o8Hj1wuuzoKcW3DfVzaP6VuNg== dependencies: is-number "^3.0.0" repeat-string "^1.6.1" @@ -4640,29 +4666,14 @@ tough-cookie@^2.3.3, tough-cookie@^2.3.4, tough-cookie@~2.5.0: tr46@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/tr46/-/tr46-1.0.1.tgz#a8b13fd6bfd2489519674ccde55ba3693b706d09" - integrity sha1-qLE/1r/SSJUZZ0zN5VujaTtwbQk= + integrity sha512-dTpowEjclQ7Kgx5SdBkqRzVhERQXov8/l9Ft9dVM9fmg0W0KQSVaXX9T4i6twCPNtYiZM53lpSSUAwJbFPOHxA== dependencies: punycode "^2.1.0" -trim-newlines@^1.0.0: - version "1.0.0" - resolved "http://registry.npm.dtstack.com/trim-newlines/-/trim-newlines-1.0.0.tgz#5887966bb582a4503a41eb524f7d35011815a613" - integrity sha1-WIeWa7WCpFA6QetST301ARgVphM= - -trim-newlines@^2.0.0: - version "2.0.0" - resolved "http://registry.npm.dtstack.com/trim-newlines/-/trim-newlines-2.0.0.tgz#b403d0b91be50c331dfc4b82eeceb22c3de16d20" - integrity sha1-tAPQuRvlDDMd/EuC7s6yLD3hbSA= - trim-newlines@^3.0.0: - version "3.0.0" - resolved "http://registry.npm.dtstack.com/trim-newlines/-/trim-newlines-3.0.0.tgz#79726304a6a898aa8373427298d54c2ee8b1cb30" - integrity sha1-eXJjBKaomKqDc0JymNVMLuixyzA= - -trim-off-newlines@^1.0.0: - version "1.0.1" - resolved "http://registry.npm.dtstack.com/trim-off-newlines/-/trim-off-newlines-1.0.1.tgz#9f9ba9d9efa8764c387698bcbfeb2c848f11adb3" - integrity sha1-n5up2e+odkw4dpi8v+sshI8RrbM= + version "3.0.1" + resolved "https://registry.yarnpkg.com/trim-newlines/-/trim-newlines-3.0.1.tgz#260a5d962d8b752425b32f3a7db0dcacd176c144" + integrity sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw== ts-jest@^24.1.0: version "24.3.0" @@ -4681,28 +4692,28 @@ ts-jest@^24.1.0: yargs-parser "10.x" tslib@^1.8.1: - version "1.13.0" - resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.13.0.tgz#c881e13cc7015894ed914862d276436fa9a47043" - integrity sha512-i/6DQjL8Xf3be4K/E6Wgpekn5Qasl1usyw++dAA35Ue5orEn65VIxOA+YvNNl9HV3qv70T7CNwjODHZrLwvd1Q== + version "1.14.1" + resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00" + integrity sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg== tsutils@^3.17.1: - version "3.17.1" - resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.17.1.tgz#ed719917f11ca0dee586272b2ac49e015a2dd759" - integrity sha512-kzeQ5B8H3w60nFY2g8cJIuH7JDpsALXySGtwGJ0p2LSjLgay3NdIpqq5SoOBe46bKDW2iq25irHCr8wjomUS2g== + version "3.21.0" + resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623" + integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA== dependencies: tslib "^1.8.1" tunnel-agent@^0.6.0: version "0.6.0" resolved "https://registry.yarnpkg.com/tunnel-agent/-/tunnel-agent-0.6.0.tgz#27a5dea06b36b04a0a9966774b290868f0fc40fd" - integrity sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0= + integrity sha512-McnNiV1l8RYeY8tBgEpuodCC1mLUdbSN+CYBL7kJsJNInOP8UjDDEwdk6Mw60vdLLrr5NHKZhMAOSrR2NZuQ+w== dependencies: safe-buffer "^5.0.1" tweetnacl@^0.14.3, tweetnacl@~0.14.0: version "0.14.5" resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-0.14.5.tgz#5ae68177f192d4456269d108afa93ff8743f4f64" - integrity sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q= + integrity sha512-KXXFFdAbFXY4geFIwoyNK+f5Z1b7swfXABfL7HXCmoIWMKU3dmS26672A4EeQtDzLKy7SXmfBu51JolvEKwtGA== type-check@^0.4.0, type-check@~0.4.0: version "0.4.0" @@ -4714,19 +4725,24 @@ type-check@^0.4.0, type-check@~0.4.0: type-check@~0.3.2: version "0.3.2" resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72" - integrity sha1-WITKtRLPHTVeP7eE8wgEsrUg23I= + integrity sha512-ZCmOJdvOWDBYJlzAoFkC+Q0+bUyEOS1ltgp1MGU03fqHG+dbi9tBFU2Rd9QKiDZFAYrhPh2JUf7rZRIuHRKtOg== dependencies: prelude-ls "~1.1.2" type-fest@^0.18.0: version "0.18.1" - resolved "http://registry.npm.dtstack.com/type-fest/-/type-fest-0.18.1.tgz#db4bc151a4a2cf4eebf9add5db75508db6cc841f" - integrity sha1-20vBUaSiz07r+a3V23VQjbbMhB8= + resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.18.1.tgz#db4bc151a4a2cf4eebf9add5db75508db6cc841f" + integrity sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw== + +type-fest@^0.20.2: + version "0.20.2" + resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.20.2.tgz#1bf207f4b28f91583666cb5fbd327887301cd5f4" + integrity sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ== type-fest@^0.6.0: version "0.6.0" - resolved "http://registry.npm.dtstack.com/type-fest/-/type-fest-0.6.0.tgz#8d2a2370d3df886eb5c90ada1c5bf6188acf838b" - integrity sha1-jSojcNPfiG61yQraHFv2GIrPg4s= + resolved "https://registry.yarnpkg.com/type-fest/-/type-fest-0.6.0.tgz#8d2a2370d3df886eb5c90ada1c5bf6188acf838b" + integrity sha512-q+MB8nYR1KDLrgr4G5yemftpMC7/QLqVndBmEEdqzmNj5dcFOO4Oo8qlwZE3ULT3+Zim1F8Kq4cBnikNhlCMlg== type-fest@^0.8.1: version "0.8.1" @@ -4735,18 +4751,28 @@ type-fest@^0.8.1: typedarray@^0.0.6: version "0.0.6" - resolved "http://registry.npm.dtstack.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777" - integrity sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c= + resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777" + integrity sha512-/aCDEGatGvZ2BIk+HmLf4ifCJFwvKFNb9/JeZPMulfgFracn9QFcAf5GO8B/mweUjSoblS5In0cWhqpfs/5PQA== -typescript@^3.6.3: - version "3.9.7" - resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.9.7.tgz#98d600a5ebdc38f40cb277522f12dc800e9e25fa" - integrity sha512-BLbiRkiBzAwsjut4x/dsibSTB6yWpwT5qWmC2OfuCg3GgVQCSgMs4vEctYPhsaGtd0AeuuHMkjZ2h2WG8MSzRw== +typescript@^4.9.4: + version "4.9.4" + resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.9.4.tgz#a2a3d2756c079abda241d75f149df9d561091e78" + integrity sha512-Uz+dTXYzxXXbsFpM86Wh3dKCxrQqUcVMxwU54orwlJjOpO3ao8L7j5lH+dWfTwgCwIuM9GQ2kvVotzYJMXTBZg== uglify-js@^3.1.4: - version "3.13.5" - resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.13.5.tgz#5d71d6dbba64cf441f32929b1efce7365bb4f113" - integrity sha512-xtB8yEqIkn7zmOyS2zUNBsYCBRhDkvlNxMMY2smuJ/qA8NCHeQvKCF3i9Z4k8FJH4+PJvZRtMrPynfZ75+CSZw== + version "3.17.4" + resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.17.4.tgz#61678cf5fa3f5b7eb789bb345df29afb8257c22c" + integrity sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g== + +unbox-primitive@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/unbox-primitive/-/unbox-primitive-1.0.2.tgz#29032021057d5e6cdbd08c5129c226dff8ed6f9e" + integrity sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw== + dependencies: + call-bind "^1.0.2" + has-bigints "^1.0.2" + has-symbols "^1.0.3" + which-boxed-primitive "^1.0.2" union-value@^1.0.0: version "1.0.1" @@ -4761,22 +4787,30 @@ union-value@^1.0.0: unset-value@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/unset-value/-/unset-value-1.0.0.tgz#8376873f7d2335179ffb1e6fc3a8ed0dfc8ab559" - integrity sha1-g3aHP30jNRef+x5vw6jtDfyKtVk= + integrity sha512-PcA2tsuGSF9cnySLHTLSh2qrQiJ70mn+r+Glzxv2TWZblxsxCC52BDlZoPCsz7STd9pN7EZetkWZBAvk4cgZdQ== dependencies: has-value "^0.3.1" isobject "^3.0.0" +update-browserslist-db@^1.0.9: + version "1.0.10" + resolved "https://registry.yarnpkg.com/update-browserslist-db/-/update-browserslist-db-1.0.10.tgz#0f54b876545726f17d00cd9a2561e6dade943ff3" + integrity sha512-OztqDenkfFkbSG+tRxBeAnCVPckDBcvibKd35yDONx6OU8N7sqgwc7rCbkJ/WcYtVRZ4ba68d6byhC21GFh7sQ== + dependencies: + escalade "^3.1.1" + picocolors "^1.0.0" + uri-js@^4.2.2: - version "4.2.2" - resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.2.2.tgz#94c540e1ff772956e2299507c010aea6c8838eb0" - integrity sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ== + version "4.4.1" + resolved "https://registry.yarnpkg.com/uri-js/-/uri-js-4.4.1.tgz#9b1a52595225859e55f669d928f88c6c57f2a77e" + integrity sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg== dependencies: punycode "^2.1.0" urix@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72" - integrity sha1-2pN/emLiH+wf0Y1Js1wpNQZ6bHI= + integrity sha512-Am1ousAhSLBeB9cG/7k7r2R0zj50uDRlZHPGbazid5s9rlF1F/QKYObEKSIunSjIOkJZqwRRLpvewjEkM7pSqg== use@^3.1.0: version "3.1.1" @@ -4785,18 +4819,19 @@ use@^3.1.0: util-deprecate@^1.0.1, util-deprecate@~1.0.1: version "1.0.2" - resolved "http://registry.npm.dtstack.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf" - integrity sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8= + resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf" + integrity sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw== util.promisify@^1.0.0: - version "1.0.1" - resolved "https://registry.yarnpkg.com/util.promisify/-/util.promisify-1.0.1.tgz#6baf7774b80eeb0f7520d8b81d07982a59abbaee" - integrity sha512-g9JpC/3He3bm38zsLupWryXHoEcS22YHthuPQSJdMy6KNrzIRzWqcsHzD/WUnqe45whVou4VIsPew37DoXWNrA== + version "1.1.1" + resolved "https://registry.yarnpkg.com/util.promisify/-/util.promisify-1.1.1.tgz#77832f57ced2c9478174149cae9b96e9918cd54b" + integrity sha512-/s3UsZUrIfa6xDhr7zZhnE9SLQ5RIXyYfiVnMMyMDzOc8WhWN4Nbh36H842OyurKbCDAesZOJaVyvmSl6fhGQw== dependencies: + call-bind "^1.0.0" define-properties "^1.1.3" - es-abstract "^1.17.2" + for-each "^0.3.3" has-symbols "^1.0.1" - object.getownpropertydescriptors "^2.1.0" + object.getownpropertydescriptors "^2.1.1" uuid@^3.3.2: version "3.4.0" @@ -4804,9 +4839,9 @@ uuid@^3.3.2: integrity sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A== v8-compile-cache@^2.0.3: - version "2.1.1" - resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.1.1.tgz#54bc3cdd43317bca91e35dcaf305b1a7237de745" - integrity sha512-8OQ9CL+VWyt3JStj7HX7/ciTL2V3Rl1Wf5OL+SNTm0yK1KvtReVulksyeRnCANHHuUxHlQig+JJDlUhBt1NQDQ== + version "2.3.0" + resolved "https://registry.yarnpkg.com/v8-compile-cache/-/v8-compile-cache-2.3.0.tgz#2de19618c66dc247dcfb6f99338035d8245a2cee" + integrity sha512-l8lCEmLcLYZh4nbunNZvQCJc5pv7+RCwa8q/LdUx8u7lsWvPDKmpodJAJNwkAhJC//dFY48KuIEmjtd4RViDrA== validate-npm-package-license@^3.0.1: version "3.0.4" @@ -4819,7 +4854,7 @@ validate-npm-package-license@^3.0.1: verror@1.10.0: version "1.10.0" resolved "https://registry.yarnpkg.com/verror/-/verror-1.10.0.tgz#3a105ca17053af55d6e270c1f8288682e18da400" - integrity sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA= + integrity sha512-ZZKSmDAEFOijERBLkmYfJ+vmk3w+7hOLYDNkRCuRuMJGEmqYNCNLyBBFwWKVMhfwaEF3WOd0Zlw86U/WC/+nYw== dependencies: assert-plus "^1.0.0" core-util-is "1.0.2" @@ -4833,11 +4868,11 @@ w3c-hr-time@^1.0.1: browser-process-hrtime "^1.0.0" walker@^1.0.7, walker@~1.0.5: - version "1.0.7" - resolved "https://registry.yarnpkg.com/walker/-/walker-1.0.7.tgz#2f7f9b8fd10d677262b18a884e28d19618e028fb" - integrity sha1-L3+bj9ENZ3JisYqITijRlhjgKPs= + version "1.0.8" + resolved "https://registry.yarnpkg.com/walker/-/walker-1.0.8.tgz#bd498db477afe573dc04185f011d3ab8a8d7653f" + integrity sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ== dependencies: - makeerror "1.0.x" + makeerror "1.0.12" webidl-conversions@^4.0.2: version "4.0.2" @@ -4874,10 +4909,21 @@ whatwg-url@^7.0.0: tr46 "^1.0.1" webidl-conversions "^4.0.2" +which-boxed-primitive@^1.0.2: + version "1.0.2" + resolved "https://registry.yarnpkg.com/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz#13757bc89b209b049fe5d86430e21cf40a89a8e6" + integrity sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg== + dependencies: + is-bigint "^1.0.1" + is-boolean-object "^1.1.0" + is-number-object "^1.0.4" + is-string "^1.0.5" + is-symbol "^1.0.3" + which-module@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/which-module/-/which-module-2.0.0.tgz#d9ef07dce77b9902b8a3a8fa4b31c3e3f7e6e87a" - integrity sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho= + integrity sha512-B+enWhmw6cjfVC7kS8Pj9pCrKSc5txArRyaYGe088shv/FGWH+0Rjx/xPgtsWfsUtS27FkP697E4DDhgrgoc0Q== which@^1.2.9, which@^1.3.0: version "1.3.1" @@ -4901,7 +4947,7 @@ word-wrap@^1.2.3, word-wrap@~1.2.3: wordwrap@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb" - integrity sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus= + integrity sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q== wrap-ansi@^5.1.0: version "5.1.0" @@ -4912,10 +4958,10 @@ wrap-ansi@^5.1.0: string-width "^3.0.0" strip-ansi "^5.0.0" -wrap-ansi@^6.2.0: - version "6.2.0" - resolved "http://registry.npm.dtstack.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53" - integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA== +wrap-ansi@^7.0.0: + version "7.0.0" + resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43" + integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q== dependencies: ansi-styles "^4.0.0" string-width "^4.1.0" @@ -4924,7 +4970,7 @@ wrap-ansi@^6.2.0: wrappy@1: version "1.0.2" resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" - integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8= + integrity sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ== write-file-atomic@2.4.1: version "2.4.1" @@ -4935,17 +4981,10 @@ write-file-atomic@2.4.1: imurmurhash "^0.1.4" signal-exit "^3.0.2" -write@1.0.3: - version "1.0.3" - resolved "https://registry.yarnpkg.com/write/-/write-1.0.3.tgz#0800e14523b923a387e415123c865616aae0f5c3" - integrity sha512-/lg70HAjtkUgWPVZhZcm+T4hkL8Zbtp1nFNOn3lRrxnlv50SRBv7cR7RqR+GMsd3hUXy9hWBo4CHTbFTcOYwig== - dependencies: - mkdirp "^0.5.1" - ws@^5.2.0: - version "5.2.2" - resolved "https://registry.yarnpkg.com/ws/-/ws-5.2.2.tgz#dffef14866b8e8dc9133582514d1befaf96e980f" - integrity sha512-jaHFD6PFv6UgoIVda6qZllptQsMlDEJkTQcybzzXDYM1XO9Y8em691FGMPmM46WGyLU4z9KMgQN+qrux/nhlHA== + version "5.2.3" + resolved "https://registry.yarnpkg.com/ws/-/ws-5.2.3.tgz#05541053414921bc29c63bee14b8b0dd50b07b3d" + integrity sha512-jZArVERrMsKUatIdnLzqvcfydI85dvd/Fp1u/VOpfdDWQ4c9qWXe+VIeAbQ5FrDwciAkr+lzofXLz3Kuf26AOA== dependencies: async-limiter "~1.0.0" @@ -4956,17 +4995,22 @@ xml-name-validator@^3.0.0: xtend@~4.0.1: version "4.0.2" - resolved "http://registry.npm.dtstack.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54" - integrity sha1-u3J3n1+kZRhrH0OPZ0+jR/2121Q= + resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54" + integrity sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ== y18n@^4.0.0: - version "4.0.1" - resolved "https://registry.yarnpkg.com/y18n/-/y18n-4.0.1.tgz#8db2b83c31c5d75099bb890b23f3094891e247d4" - integrity sha512-wNcy4NvjMYL8gogWWYAO7ZFWFfHcbdbE57tZO8e4cbpj8tfUcwrwqSl3ad8HxpYWCdXcJUCeKKZS62Av1affwQ== + version "4.0.3" + resolved "https://registry.yarnpkg.com/y18n/-/y18n-4.0.3.tgz#b5f259c82cd6e336921efd7bfd8bf560de9eeedf" + integrity sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ== + +y18n@^5.0.5: + version "5.0.8" + resolved "https://registry.yarnpkg.com/y18n/-/y18n-5.0.8.tgz#7f4934d0f7ca8c56f95314939ddcd2dd91ce1d55" + integrity sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA== yallist@^4.0.0: version "4.0.0" - resolved "http://registry.npm.dtstack.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72" + resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72" integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A== yargs-parser@10.x: @@ -4984,18 +5028,10 @@ yargs-parser@^13.1.2: camelcase "^5.0.0" decamelize "^1.2.0" -yargs-parser@^18.1.2: - version "18.1.3" - resolved "http://registry.npm.dtstack.com/yargs-parser/-/yargs-parser-18.1.3.tgz#be68c4975c6b2abf469236b0c870362fab09a7b0" - integrity sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ== - dependencies: - camelcase "^5.0.0" - decamelize "^1.2.0" - -yargs-parser@^20.2.3: - version "20.2.4" - resolved "http://registry.npm.dtstack.com/yargs-parser/-/yargs-parser-20.2.4.tgz#b42890f14566796f85ae8e3a25290d205f154a54" - integrity sha1-tCiQ8UVmeW+Fro46JSkNIF8VSlQ= +yargs-parser@^20.2.2, yargs-parser@^20.2.3: + version "20.2.9" + resolved "https://registry.yarnpkg.com/yargs-parser/-/yargs-parser-20.2.9.tgz#2eb7dc3b0289718fc295f362753845c41a0c94ee" + integrity sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w== yargs@^13.3.0: version "13.3.2" @@ -5013,24 +5049,20 @@ yargs@^13.3.0: y18n "^4.0.0" yargs-parser "^13.1.2" -yargs@^15.3.1: - version "15.4.1" - resolved "http://registry.npm.dtstack.com/yargs/-/yargs-15.4.1.tgz#0d87a16de01aee9d8bec2bfbf74f67851730f4f8" - integrity sha1-DYehbeAa7p2L7Cv7909nhRcw9Pg= +yargs@^16.0.0, yargs@^16.2.0: + version "16.2.0" + resolved "https://registry.yarnpkg.com/yargs/-/yargs-16.2.0.tgz#1c82bf0f6b6a66eafce7ef30e376f49a12477f66" + integrity sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw== dependencies: - cliui "^6.0.0" - decamelize "^1.2.0" - find-up "^4.1.0" - get-caller-file "^2.0.1" + cliui "^7.0.2" + escalade "^3.1.1" + get-caller-file "^2.0.5" require-directory "^2.1.1" - require-main-filename "^2.0.0" - set-blocking "^2.0.0" string-width "^4.2.0" - which-module "^2.0.0" - y18n "^4.0.0" - yargs-parser "^18.1.2" + y18n "^5.0.5" + yargs-parser "^20.2.2" yocto-queue@^0.1.0: version "0.1.0" - resolved "http://registry.npm.dtstack.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b" + resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b" integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==